Determination of pharmacogenomic gene star alleles using high throughput targeted genotyping

Abstract

Determining pharmacogenomic genomic astronomy alleles using high-throughput targeted genotyping includes: obtaining input gene sequence variation data from a high-throughput genotyping platform based on a sample's pharmacogenomic genotyping; applying a Bayesian graphic model to determine a plurality of different astronomy allele calls corresponding to the sample; and providing a respective mass fraction for each of the plurality of different astronomical allelic calls. For example, application of the Bayesian graphic model uses multiple solution integer programming to explore a model space of the Bayesian graphic model in a first stage including structural variant candidate identification and a second stage including astronomical allele candidate identification based on the structural variant candidate identification, to determine the plurality of different astronomy allele calls.

Description

Background Art

[0001] Pharmacogenomics (PGx) studies the role of genetic variation in an individual's response to drug type and dose, with the goal of providing personalized treatment recommendations for better efficacy and reduced side effects. Many genes are involved in regulating an individual's drug response. Examples of PGx genes include:

[0002] CYP2D6, G6PD, CYP2C19, CYP2C9, HLA-B, UGT1A1, CACNA1S, RYR1, TPMT, CYP2B6, DPYD, SLCO1B1, CYP3A5, VKORC1, CYP4F2, CFTR, F5, NUDT15, IFNL3 / IFNL4, HLA-A, MT-RNR1 and CYP2A6.

[0003] Typically, a PGx gene contains one or more core variants. Core variants are typically single nucleotide variants or small insertions and deletions on a PGx gene that alter the function of the translated protein. The combination of core variants determines the function of the protein, such as the function of drug metabolism. Star alleles (sometimes written as "star alleles") are validated combinations or haplotypes of these core variants that have been found to exist in a population. Star alleles can also include structural variations (SVs), including hybridization, duplication, deletion, etc. with nearby pseudogenes. Summary of the invention

[0004] The disadvantages of the prior art are overcome and additional advantages are provided by providing a computer-implemented method for determining the star allele of a pharmacogenomics gene using high-throughput targeted genotyping. The method obtains input gene sequence variation data from a high-throughput genotyping platform based on pharmacogenomic genotyping of a sample; applies a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample; and provides a corresponding quality score for each star allele call in the plurality of different star allele calls.

[0005] Further, a computer system is provided, the computer system comprising a memory and a processor in communication with the memory, wherein the computer system is configured to perform a method for determining a pharmacogenomics gene star allele using high-throughput targeted genotyping. The method obtains input gene sequence variation data from a high-throughput genotyping platform based on pharmacogenomics genotyping of a sample; applies a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample; and provides a corresponding quality score for each star allele call in the plurality of different star allele calls.

[0006] Still further, a computer program product is provided, the computer program product comprising a computer-readable storage medium that can be read by a processing circuit and stores instructions for execution by the processing circuit to perform a method for determining a pharmacogenomics gene star allele using high-throughput targeted genotyping. The method obtains input gene sequence variation data from a high-throughput genotyping platform based on pharmacogenomics genotyping of a sample; applies a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample; and provides a corresponding quality score for each star allele call in the plurality of different star allele calls.

[0007] In one or more embodiments, the high-throughput genotyping platform comprises a microarray-based genotyping platform.

[0008] In one or more embodiments, the input genetic sequence variation data includes genotype data and copy number variant call data.

[0009] In one or more embodiments, the genotype data and the copy number data include B allele frequency (BAF) and log R ratio data.

[0010] In one or more embodiments, the Bayesian graphical model is applied using multi-solution integer programming to explore the model space of the Bayesian graphical model in (i) a first stage comprising structural variant (SV) candidate identification and (ii) a second stage comprising star allele candidate identification based on the SV candidate identification to determine the multiple different star allele calls.

[0011] In one or more embodiments, the first stage identifies a plurality of SV candidates and evaluates, for each SV candidate in the plurality of SV candidates, a cost of the SV candidate.

[0012] In one or more embodiments, the cost of the SV candidate comprises a log-transformed likelihood.

[0013] In one or more embodiments, a plurality of SV candidates that meet or exceed a predefined likelihood threshold among the plurality of SV candidates are output from the first stage to generate a plurality of SV candidates provided to the second stage.

[0014] In one or more embodiments, constraints are provided as part of the SV candidate identification to ensure that at least two SV candidates are provided to the second stage.

[0015] In one or more embodiments, the second stage identifies a plurality of star allele candidates and evaluates, for each star allele candidate in the plurality of star allele candidates, a cost for the star allele candidate.

[0016] In one or more embodiments, the cost for the star allele candidate comprises a log-transformed likelihood.

[0017] In one or more embodiments, each star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model corresponds to a star allele candidate identified by the second stage and a corresponding SV candidate identified by the first stage, and the corresponding quality score of the star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model comprises a synthesis of (i) the cost of the star allele candidate identified by the second stage and (ii) the cost of the SV candidate identified by the first stage.

[0018] In one or more embodiments, the synthesis includes the sum of the cost of the star allele candidate identified by the second stage and the cost of the SV candidate identified by the first stage.

[0019] In one or more embodiments, the Bayesian graphical model considers the quality and population frequency of structural variants and star alleles in determining the corresponding quality score for each star allele call in the plurality of different star allele calls.

[0020] In one or more embodiments, the method further comprises ranking the plurality of different star allele calls based on the corresponding quality score of each star allele call in the plurality of different star allele calls.

[0021] In one or more embodiments, the corresponding quality score for each star allele call in the plurality of different star allele calls comprises a log-transformed likelihood converted to a posterior probability.

[0022] In one or more embodiments, the method further comprises providing, for each star allele call in the plurality of different star allele calls, one or more of: (i) supporting variants for the star allele call, (ii) missing and / or masked core variants, or (iii) missing drug-genome-associated variants.

[0023] Additional features and advantages are achieved through the concepts described herein. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] The various aspects described herein are particularly pointed out and clearly claimed as examples in the claims at the end of this specification. The foregoing and other objects, features and advantages of the present disclosure will become apparent from the following detailed description taken in conjunction with the accompanying drawings, in which:

[0025] Figure 1Depicted are exemplary workflows according to various aspects described herein;

[0026] Figure 2 depicts an exemplary Bayesian graphical model in accordance with various aspects described herein;

[0027] Figure 3 Depicts an SV model space associated with the SV model space according to various aspects described herein. Figure 2 ) exemplary subnetwork;

[0028] Figure 4 depicts examples of SV configuration probabilities according to various aspects described herein;

[0029] Figure 5 depicts an exemplary NR probability calculation in accordance with various aspects described herein;

[0030] Figure 6 Depicted are ( Figure 2 ) exemplary subnetwork;

[0031] Figure 7A-7G depicts an exemplary result output of a candidate solution according to various aspects described herein;

[0032] Figure 8A-8B depicts additional exemplary result outputs of candidate solutions according to various aspects described herein;

[0033] Figure 9A-9C depicts exemplary comparative results obtained from testing the StARray method with conventional invokers;

[0034] Fig.10 Depicted are exemplary methods for star allele calling according to various aspects described herein; and

[0035] Fig.11 Examples of computer systems and associated devices that may incorporate and / or use aspects described herein are depicted. DETAILED DESCRIPTION

[0036] For many PGx applications, it is desirable to determine the diplotype of the PGx gene, i.e., determine the asterisk allele combination present in the diploid human genome. The various aspects presented herein describe methods for PGx gene diplotyping (diplotyping). Examples use high-throughput targeted genotyping by high-throughput genotyping platforms. In one example, a microarray-based genotyping platform, such as the BeadArray technology provided by Illumina, Inc. of San Diego, California, is used. Illumina's BeadArray and InfiniumAssay provide genotypes of specific PGx minor variant alleles, and copy number calls associated with specific target regions of minor variants or PGx genes. In different examples, the high-throughput genotyping platform includes a targeted next generation sequencing (NGS) platform. The asterisk allele calling method presented herein enables determination of the diplotype in a sample from minor variant genotypes, associated B allele frequencies (BAFs) and subgene copy numbers of the PGx gene of interest.

[0037] In the example:

[0038] Aspects described herein use array genotyping and copy number variant (CNV) calling and raw signals (R and BAF) as input;

[0039] The exemplary method is tolerant to noise as well as genotyping and CNV errors;

[0040] · The exemplary method combines structural variant and star allele determination in one coherent framework;

[0041] The exemplary method provides a quality metric associated with the determined star allele;

[0042] The exemplary method provides ranked alternative star allele interpretations of the samples;

[0043] • The exemplary method captures the population frequencies of variants and star alleles to enable population-specific star allele detection.

[0044] Star allele calling is a challenging task, especially for complex loci such as the CYP2D6 / CYP2D7 locus, which has more than 140 known CYP2D6 star alleles and structural variant configurations in the population. The following steps are traditionally followed to determine star alleles: (i) core variant detection, (ii) SV detection, and (iii) phasing variants to star alleles.

[0045] As examples, challenges of star allele calling include high homology between the gene of interest and its pseudogenes, data- and platform-specific error patterns, incomplete PGx database information and normalization, accurate SV calling, and phasing of distal core variants.

[0046] Arrays provide powerful tools for identifying tens of thousands of PGx biomarkers in thousands of samples in high-throughput workflows. Various aspects described herein provide tools (which may be referred to herein as StARray) for identifying star alleles on array platforms. The tool presents several advances in solving challenges specific to array data through novel model-based methods (e.g., based on Bayesian graphical models customized for array data types). Bayesian graphical models (also referred to as Bayesian networks) are probabilistic models of an exemplary type. Multi-solution integer programming is used to explore the Bayesian graphical model space in the following two stages: 1) SV solutions (i.e., SV candidates) are identified; and 2) allele solutions (i.e., star allele candidates) as described herein are identified to determine different possible star allele calls and score them for output.

[0047] Figure 1 An exemplary workflow of StARray is depicted. The workflow may be performed by one or more computer systems, i.e., by executing one or more processes to perform the functions. Figure 1 , the StARray process (at 1.) receives input gene sequence variation data. In the example, this is done via one or more variant call format (vcf) data files. As a specific example, the process receives a cnv.vcf file and a snv.vcf file generated by a CNV caller tool. The cnv.vcf file contains information about CNV events, while the snv.vcf file contains information about single nucleotide variants (SNVs) and indel events.

[0048] Additional aspects of the workflow relate to StARray performing integer programming (IP) to explore array-specific Bayesian graphical model space. According to the embodiments described herein, the model space is decomposed into two sub-problems and associated sub-networks (102, 104): 1) SV solution model (for SV candidate identification), and 2) star allele solution model (for star allele candidate identification). Therefore, the StARray process (at 2.) applies SV integer programming (SV IP) to explore the SV model space and evaluate the cost of each SV solution (e.g., as a log-transformed likelihood). Solutions that meet / exceed (automatically and / or by a user) a predefined likelihood ratio threshold can be returned / output from the SV IP, thereby generating one or more SV solutions (also referred to herein as "candidate SV solutions" or simply "SV candidates") to be output to the next stage.

[0049] Then, for each candidate SV solution in the candidate SV solutions that meet the likelihood ratio threshold (i.e., the output of the SV IP), the StARray process (at 3.) utilizes allele integer programming (allele IP) to explore the constrained allele model space and evaluates the cost (e.g., log-transformed likelihood) of each possible allele solution (also referred to herein as a "star allele candidate"). The likelihood of the entire graphical model is the sum of the likelihoods of these SV and allele 'subproblems'. Thus, the workflow generates one or more SV+allele candidate solutions (calls), each with a corresponding likelihood determined according to the cost / likelihood of the SV subproblem and the cost / likelihood of the allele subproblem. In the embodiments discussed herein, "likelihood" and "log-likelihood" refer to negative log-likelihood, also known as logical loss.

[0050] Discuss Now Figure 1 Further details of the workflows presented generally in Aspects utilize platform-specific Bayesian graphical models for array data. Figure 2 Such an exemplary Bayesian graphical model is depicted. Figure 2 The graphical model is Figure 1 A synthesis of models 102 and 104.

[0051] The likelihood of a particular SV solution found by the SV IP is P(CNV call|SV)P(NR|SV configuration)P(SV configuration|population), which is further explained below. The likelihood of a particular allele solution found by the Allele IP (also interchangeably referred to herein as 'star allele IP') is P(base allele|SV configuration, population)P(BAF|base allele, sample error, systematic error)P(sample error|base allele, systematic error)P(systematic error), which is further explained below. These likelihoods are derived from a graphical structure that follows the principles of a Bayesian graphical model.

[0052] exist Figure 2 , NR 202 is the normalized Log R ratio (LRR) generated by the CNV caller tool for a given gene region. Value CNV call 204 is the copy number call generated by the CNV caller tool for a given gene region. SV configuration 206 is the configuration of the SV variation obtained by SV IP. For example, each aspect can return two complete alleles and 1 hybrid allele as the SV configuration solution. Population 208 is the population used to calculate SV and star allele frequencies. This part of the Bayesian graphical model is solved by SV IP.

[0053] The base allele 210 is the star allele called by the allele IP. For example, for the complete CYP2D6SV, the base star allele can be CYP2D6*2 or CYP2D6*4. BAF 212 is the B allele frequency of the core variant of the star allele in a given allele solution. The systematic error 214 (which may also be referred to herein as the systematic error) is the frequency of the B allele in the core variant of the star allele. Error or Systematic_error) refers to the presence of clustering (e.g., GenTrain clustering) errors or assay batch effects, resulting in excessive false positive variant calls. StARray can detect such variant-level systematic errors by comparing sample variant call frequencies to known variant population frequencies using a normal approximation (as an example). The sample error 216 is the distance of the sample from the cluster center and is reflected by the GenCall (GS) score. Allele IP is used to find a feasible solution for this component of the Bayesian graph using the feasible SV solution generated and output by SV IP.

[0054] SV IP:

[0055] SV calling uses integer programming (IP) to explore the solution space of a Bayesian graphical model to find the solution set of structural variants (SVs) corresponding to the input CNV region from a given cnv.vcf file. A feature of SV IP is that, unlike other solutions, it can return multiple SV candidates that meet a likelihood ratio threshold. The high-level pseudocode for SV IP can be found below.

[0056] An exemplary pseudo code for the SV IP is as follows:

[0057]

[0058]

[0059] SV IP Model:

[0060] For the gene of interest, there are known structural variants. In the StARray caller, these structural variants are encoded as a set of binary vectors [sv_vectors] ("sv_configs"), where 1 indicates the presence of an exon or intron, and 0 indicates the absence of an exon or intron. Other regions can also be represented in vectors, including upstream and downstream of the gene of interest. An exemplary set of sv_configs showing three SV vectors is as follows: [[1 1 1 1 1 1 1 1 1 1 1 1] [1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 1 1 1 1 1 1 1 1 1]]

[0064] For CYP2D6, if all binary vectors are read from top to bottom, the set of the above three sv_vectors can represent (i) the complete allele, (ii) the 3' deletion, and (iii) the 5' hybridization to CYP2D6.

[0065] Each of the sv_vectors is also associated with a class, such as 'full allele', CYP2D6*13, CYP2D6*68, etc. Each type of class can have one or more sv_vectors. For example, the sv_vectors [0,0,0,1,1,1,] and [0,0,1,1,1,1] both belong to the CYP2D6*13 class, indicating a CYP2D7-CYP2D6 hybrid. The vector cg_config is used to track counts for these various sv_vector classes selected / called by the SV IP. For example, if two intact alleles, one CYP2D6*13, and two CYP2D6*68 alleles are selected, an exemplary cg_config appears to be [2,1,0,2,0], where the elements of cg_config correspond to the counts of (i) intact, (ii) CYP2D6*13, (iii) CYP2D6*36, (iv) CYP2D6*68, and (v) CYP2D6*5, respectively.

[0066] The StARray SV caller also builds a CNV vector from the input cnv.vcf file, which is referred to herein as cnv_vector. An example of a CNV vector is [2,0,2,0,0,3,3], where each number represents the number of copies of an exon or intron (and / or other regions upstream or downstream of the gene of interest) derived from the cnv.vcf file. If an exon / intron is not represented in the cnv.vcf file, the value in its corresponding position of the CNV vector is 0, and its weight in the cost function becomes zero because it does not contribute to the solution. Weighting is done by a weight vector (referred to herein as v weight ) to complete. Such exemplary weight =[p qual ,0,p qual ,0,0,p qual ,p qual ], where the weight of a region is either (i) the probability transformed Phred score from the cnv.vcf file (if the region is in the cnv.vcf file) or (ii) 0 (if the region is not represented in the cnv.vcf file).

[0067] A vector x_selection with selected variables is also introduced. The x_selection vector has [x0, x1, …, x n ], where each x i Indicates the number of copies of sv_vector from sv_configs in the solution.

[0068] In the above case, the integer programming cost function is constructed as follows:

[0069] Cost = ∑v∈|v weight ×(cn vector -(x seletion ×sv vconfigs ))|

[0070] Based on the above and using v weight ,cnv vector 、x selection and sv configs , the cost can be expressed as:

[0071]

[0072] where v weight The term is given by [.342, 0, .89, 0, 0, .33, .9], cnv vector The entry is cnv_vector and is given by [2,0,2,0,0,3,3], x selection The entry is the x_selection vector and is given by [x0 x1 x2], and sv configs The entries are the set of sv_configs and are given by the three vectors [1 1 1 1 1 1 1], [1 1 1 1 1 0 0], and [0 0 0 0 1 1 1].

[0073] Additional components for accounting for parsimony and SV population frequency can be added to the above cost function to ensure that solutions with greater parsimony and more common SVs are returned first. As an example, it may be desirable to ensure that two complete alleles will be returned in preference to three hybrid alleles. An exemplary representation of the cost function then becomes:

[0074] Cost = ∑v∈|v weight ×(cnv vector -(x selection ×sv configs ))|+PARSIMONY_PENALTY×sv_frequency vector ×cg_config

[0075] where sv_frequency vectorA vector of entries corresponding to the negative logarithms of the population frequencies of the SVs.

[0076] In addition, constraints can be added to the SV IP model to ensure that a minimum number (e.g., 2) of SV vectors are selected for input to the Allele IP. Such exemplary constraints for ensuring that at least two SV vectors are selected are as follows:

[0077]

[0078] SV IP returns the following:

[0079] ·x selection ;

[0080] ·(x selection ×sv configs )=[cn_exon1,cn_intron1,cn_exon2,…,cn_exon n ],

[0081] It is the updated copy number of intronic and exonic regions and is called cnv_vector updated ;

[0082] Status: if the model is feasible;

[0083] cg_config – a vector indicating counts of the selected SV categories; and

[0084] Solution cost: The corresponding calculated likelihood of each SV solution / candidate.

[0085] Multiple solution selection:

[0086] This star allele calling method is unique, at least in that it can return multiple alternative solutions for the SV IP (discussed above) and the allele IP components (discussed below) as it explores the SV and allele model space. This is achieved using the heuristic method described in detail in this paper.

[0087] To prevent redundancy of solutions generated by the SV IP model, the SV IP caller maintains the cnv_vector of previous calls. updated A list of vectors to keep track of the set of solutions from previous calls, this list is referred to in this paper as previous_solutions.

[0088] The SV IP caller returns any given cnv_vector updated Once. For example, if the returned cnv_vector updatedThe vector has the value [2,2,2,3,3], then this vector will not be returned again by the SV IP algorithm. The algorithm achieves this by using the heuristic method given below:

[0089] For each cnv_vector in previous_solutions updated :

[0090] r = random_float_vector

[0091] current_solution_sum=sum(r×(x selection ×sv configs ))

[0092] previous_solution_sum=sum(r×cnv_vector updated )

[0093] add_constraint(difference(current_solution_sum,previous_solution_sum)>0)

[0094] The above method adds the following constraint: the current cnv_vector updated The sum of vectors = (x selection ×sv configs ) is not equal to any previously generated cnv_vector updated The sum of the vector. cnv_vector updated The multiplication with the random scaling vector r ensures that there will be sums and differences between solutions that are rearrangements of each other, ie (using the above example) [2,2,3,3,3][3,3,3,2,2,]).

[0095] The constraint add_constraint(difference(current_solution_sum, previous_solution_sum)>0) is made linear as follows (as an example):

[0096] model += solution_dif <= -.00001+7*b

[0097] model += solution_dif >= .00001–7*(1-b)

[0098] where b is a binary variable. For each previous solution, two new constraints and one variable are added to the model. The presence of the parsimony penalty ensures that the cnv_vector updatedVector returns the most minimal set of sv_vectors, thus eliminating the use of the same cnv_vector updated A vector is returned where multiple solutions are needed.

[0099] Solution expansion:

[0100] Once all solutions are generated, in some embodiments, the algorithm does not further utilize the SV vectors of individual calls. Instead, the solution likelihood is calculated at a higher level selected by the SV category given by the cg_config vector. For CYP2D6, the cg_config vector can be = [2, 0, 1, 0, 0], indicating 2 complete alleles and 1 CYP2D6*68 allele.

[0101] After the likelihood calculation (discussed below), cnv_vector updated The cg_config pair is passed to expand each selected configuration category into a cnv_vector with the solution updated Function to consistent all SV vector combinations. Passes all cnv_vectors and sv_vectors generated from the unfolded solution set to the Allele IP module / process.

[0102] SV solution likelihood calculation:

[0103] When exploring the SV model space, the log-likelihood of each SV solution is calculated. The log-likelihood associated with the SV model space is ( Figure 1 The subnetwork is in Figure 3 . Referring to the SV configuration aspects 206, 306 in the subnetwork, StARray calculates P(SV|population), i.e., the probability of cg_config, given a population specified by the user (as population nodes 208, 308 in the subnetwork). Recall that cg_config is a vector of counts indicating SV categories. The likelihood of known configurations of SV categories can be pre-computed and statically stored in the StARray database. Novel or low-frequency SV category configurations can be calculated as the sum of the log probabilities of the individual SVs. An exemplary negative log-likelihood formula is given as: -log(P(CNV calls|SV))+-log(P(NR|SV))+-log(P(SV|population)).

[0104] Figure 4Examples of SV configuration probabilities for CYP2D6 are shown. Specifically, section A) shows a list of 5 possible SV classes for CYP2D6, B) shows the probabilities of various (e.g., 5 different) SV class configurations for CYP2D6, and C) shows (i) for the global population, a third such SV configuration with 2 intact alleles and one *36 hybrid allele, and its associated probability, i.e., 0.061.

[0105] refer to Figure 3 The NR node 310 in the subnetwork of , provided by the CNV caller tool (which generates the input cnv.vcf data) for each region of the gene whose copy number is calculated. updated In the case of SV solutions, StARray calculates P(NR|SV), that is, the probability of each NR value provided by the CNV caller tool. A Gaussian distribution (as an example) can be used to model the NR values. The mean and variance of the NR values ​​given the copy number of each gene region can be obtained from the internal model of the CNV caller tool. Figure 5 An exemplary NR probability calculation is shown, where A) the NR mean and variance for copy number 0-5+ of CYP2D6 are shown, and B) the NR probability formula is shown.

[0106] Finally, StARray determines P(CNV calls|SV), that is, given a cnv_vector updated For each gene region for which there is a CNV call, StARray compares the call from the CNV caller tool with the cnv_vector updated Compare the updated values ​​in the given cnv_vector and the updated vector cnv_vector updated In the case of , the probability of each gene region having a CNV call is calculated as follows:

[0107]

[0108] Star allele calling (Star Allele IP):

[0109] Allele IP for allele calling is generated by cnv_vector updatedThe expanded SV solutions / candidates composed of sv_vector set pairs and cg_config category counts are used as input. Star allele calling is a multi-solution method that uses integer programming to explore the allele Bayesian model space and find one or more sets of star alleles that are feasible solutions / candidates for given input vcf data. An exemplary high-level pseudocode for star allele IP is provided as follows:

[0110]

[0111]

[0112] The star allele call IP algorithm is a multi-solution method and uses min_heap to complete. For each sv_solution (SV candidate) generated by SV IP, min_heap tracks the cost of the next star allele solution / candidate that will be produced by processing a given sv_solution. The sv_solution that min_heap will produce the best star allele solution / candidate is maintained at the top of the heap. When each iteration, the multi-solution algorithm will have the star allele solution / candidate of the current minimum cost and pop up from the top of the heap. Then, the multi-solution algorithm utilizes current sv_solution to find new star allele solution / candidate. If this new solution is feasible, then it is added to the solution set, and sv_solution is added back to the heap with the update cost.

[0113] The various sub-functions of the multi-solution star allele calling algorithm are further detailed as follows:

[0114] create_masked_map(): The multi-solution allele calling algorithm begins by creating a masked map of probe identifiers to the Human Genome Variant Society (hgvs) labels used by the Pharmacogenomic Variants Consortium (PharmVar) and the Pharmacogenomic Knowledge Base (PharmGKB). Data from a map file, such as produced by an independent variant-to-probe identifier mapping utility, is processed by the create_masked_map function to create a dictionary mapping probes to HGVS labels. Any variants not present in the array are masked from the dictionary to create a masked map.

[0115] get_solution_setups: This function encapsulates the following functions of the above pseudo code: ab_allele_cn, ab_allele_quality = get_variant_cn_and_quality(cnv_vector updated,input_vcf);allele_list,allele_vectors,cg_config=create_feasible_allele_vectors(ab_allele_cn);rare_allele_penalties=create_rare_allele_penalty_vector(allele_list,allele_vectors). This function obtains the solution settings for each of the sv_solutions generated by the SV IP algorithm. The data generated in this aspect include a list of feasible star alleles (allele_list), a Boolean star allele vector (allele_vectors) indicating the presence or absence of variant / reference alleles in the star allele, a vector with the estimated copy number of variant / reference alleles in the sample (ab_allele_cn), a quality value of the variant / reference allele in the sample (ab_allele_quality), a cnv_vector of the sv solution updated , cg_config(struct class counts of sv_solution), and a vector indicating which star alleles in allele_list are rare alleles and the associated penalties (rare_allele_penalties).

[0116] Within the get_solution_setup function, there are several sub-functions to obtain the data described for the Allele IP solution. The sub-functions are described as follows:

[0117] get_variant_cn_and_quality(): This function generates the ab_allele_cn and ab_allele_quality vectors, which are the estimated variant / reference allele copy number and variant / reference allele quality values, respectively. An exemplary pseudocode for generating the variant copy number and quality vectors ab_allele_cn and ab_allele_quality using the B allele frequency (BAF) is as follows:

[0118]

[0119] ab_allele_quality is the logit-transformed GenCall score associated with each variant / reference allele obtained from the input snv.vcf.

[0120] create_feasible_allele_vectors(): This function takes sv_vectors from sv_solution and generates feasible star allele vectors from them. sv_vector is called again to indicate the structural variation configuration, such as, as an example, 'complete' or CYP2D6*36. For each sv_vector, all feasible base alleles are considered. For example, CYP2D6*68 may have CYP2D6*4 and CYP2D6*10 as feasible base alleles. The create_feasible_allele_vectors function generates star allele vectors of feasible star alleles given the variant / reference allele copy number coverage and quality. The calculation of the feasibility of star alleles given the sample data is described below.

[0121] If the variant belonging to the star allele is not present in the sample, the star allele is not a feasible component of the star allele solution. However, low-quality variants may be wrong in the vcf sample. In order to solve this problem, the quality of the variant (the quality value / score from the input snv.vcf) can also be considered. As an example, for the star allele that is considered feasible, the quality score of the variant belonging to the star allele but not present in the sample will be less than the threshold value (quality_cutoff) provided by the user, and at least one variant belonging to the star allele will exist. In order to be considered to be present in the sample, the variant has a copy value greater than the threshold value (coverage_cutoff) provided by another user in ab_allele_cn. The reflection of the variant present in the sample is determined by the ab_allele_cn vector, which has the copy number determined by Starray for the variant; as a specific example and not limitation, if variant i has ab_allele_cn[i]=.3 and this is less than coverage_cutoff (e.g., .9), it is considered that it does not exist in the sample. And if the quality value of variant i is relatively low, such as .7, then for the purpose of considering the star allele as a possible solution, variant i is ignored as a required variant observed in the sample. Conversely, if variant i has a relatively high quality value, such as .999, the candidate star allele can be considered infeasible as a variant because there are no high quality value variants belonging to the star allele. At the same time, in the example, StaARray also requires that at least one variant belonging to the candidate star allele is present in the sample to consider the star allele, and quality is not considered in this regard. If a different variant j associated with the candidate star allele has ab_allele_cn[i]=1.3>coverage_cutoff=.9, it is considered to be present in the sample and meets this criterion. Therefore, the foregoing provides two separate tests in this regard.

[0122] Example pseudocode for determining the viability of the star allele is shown below:

[0123]

[0124]

[0125] Once the star allele is determined to be viable, generate the allele_vector for that allele. For example:

[0126] allele_vector=[0 0 0 1 0 0 1 1 1 0 1 1]

[0127] in:

[0128] length(allele_vector)=2*length(hgvs_to_vcf_map_masked); and for i in the range (0, length(hgvs_to_vcf_map_masked)), allele_vector[i]=1 if variants[i]∈star_allele, otherwise allele_vector[i]=0; and

[0129] For i in the range (0, length(hgvs_to_vcf_map_masked)), allele_vector[i+length(hgvs_to_vcf_map_masked)]=1 (if reference_allele(variants[i])∈star_allele), otherwise allele_vector[i]=0.

[0130] The allele vector takes into account both variants and reference alleles present in the star allele. Each base star allele is constructed with respect to the superimposed sv_vector. If the sv_vector is complete, the entire star allele will be represented in the allele_vector. If the sv_vector is a hybrid or partial allele, the variant / reference allele that falls within the missing portion of the sv_vector will be set to 0 in the allele_vector.

[0131] Asterisk alleles can have optional core variants associated with them. For example, the same is true for CYP2D6*4, which is defined by one core variant, but can also have additional core variants associated with it. Note that these are not small asterisk variants, but core variants. These optional variants can be indicated by 2 in allele_vector, which will allow them to be distinguished in the creation of allele variants in allele IP programming.

[0132] So, the final allele_vector might look like:

[0133] allele_vector=[0 0 2 1 0 0 1 1 0 0 1 1]

[0134] create_rare_allele_penalty_vector(): This function creates a rare_allele_penalties vector. For each star allele in the feasible star alleles, the corresponding rare_allele_penalty is set to (1–population_frequency(star allele)), where population_frequency is the population_frequency of the star allele given the user-selected population.

[0135] Asterisk allele calling IP model:

[0136] Since all sv_solutions have generated solution_setups for star allele calling, execute the star allele calling model / function. The star allele calling function takes as input the generated solution_setups which consist of allele_list, allele_vectors, ab_allele_cn, ab_allele_quality, cnv_vectorupdated, cg_config, rare_allele_penalties.

[0137] The main form of the cost function for the star allele IP model for calling star alleles is as follows:

[0138]

[0139] The allele_selection vector is a vector indicating how many copies of the star allele there are in the star allele solution. The allele_aux_variants are variables indicating the presence or absence of an optional primary star variant (ie, core variant) for each allele_vector.

[0140] An example of ab_allele_cn is [1.82, 2.01, 2.33, 1.92, …, 1.89, 3.2, 2.9, 3.01]. An example of allele_selection is [x1, x2, x3, …, x n An example of allele_vectors is: [[1 1 1 1 1 1 1 1 1 1 1 1] [1 1 1 1 1 1 1 1 0 0 0 0 0]

[0143] [0 0 0 0 1 1 1 1 1 1 1 1]].

[0144] An example of allele_aux_variants(variant_v) is

[0145]

[0146] The star allele calling model creates the necessary allele_selection and allele_aux_variants variables required for star allele calling. The creation of the star allele IP variables is described below:

[0147] create_allele_variables(): This function takes allele_vectors, ab_allele_cn (variant and reference allele copy numbers) and structural variant category counts (i.e. cg_config) as input. For each star allele belonging to an overlay configuration category in cg_config, such as a complete allele, create a variable x i And add it to allele_selection.

[0148] If an optional core variant is indicated in the star allele allele_vector (e.g., indicated by 2), additional variables are introduced. For each optional core variant in the star allele, two variables v are introduced. alt and v ref These variables track the copy number of the optional alternative allele and the reference allele, respectively, and are maintained in the vector allele_aux_variants, one entry per star allele. The allele_aux_variants vector can be reformatted into an additional vector (variant_v) that tracks the optional primary star variant by variant rather than by star allele for use in the cost function.

[0149] The following three constraints can be added to the star allele IP model:

[0150] 1. For the star allele i Each v alt and v ref Yes, in allele_selection v alt +v ref. =x i

[0151] 2. For all star alleles = star allele 1, star allele 2, star allele 3, ..., star allele N belonging to category cg_configi, x1+x2+x3+...+x n =cg_config[i]

[0152] 3. For all ab_allele_cn[i], if ab_allele_cn[i]>=coverage_cutoff and ab_allele_quality[i]>=quality_cutoff: count(alleles_in_solution_containing_variant_i)>=1 # If the variant is present in the sample with a quality value greater than the cutoff, it must be covered by one of the star alleles in the generated solution

[0153] The above three constraints ensure, respectively, that (i) for each optional major star variant in a given star allele, the sum of the reference and alternative allele copy numbers is equal to the copy number of the star allele, (ii) the number of star alleles selected in each cg_config category is equal to the count of the cg_config category called by SV IP, and (iii) the quality of variants / reference alleles that appear in the sample but not in the solution is less than a user-provided threshold.

[0154] Star allele call likelihood calculation:

[0155] When exploring allele model space, the log-likelihood of each SV candidate is calculated (i.e., as the negative log-likelihood). The subnetwork associated with allele model space is Figure 6 As discussed above, the probability formula is given as P(base allele|SV configuration, population)P(BAF|base allele, sample error, systematic error)P(sample error|base allele, systematic error)P(systematic error). Therefore, the negative log-likelihood formula is -log(P(base allele|SV configuration, population))+-log(P(BAF|base allele, sample error, systematic error))+-log(P(sample error|base allele, systematic error))+-log(P(systematic error)).

[0156] refer to Figure 6, population 608 is the population used to calculate the frequency (see also 208, 308). SV configuration node 606 represents the probability of one of the solutions generated by SV integer programming. Given the SV configuration solution provided by SV integer programming, base allele node 610 represents the probability of the base star allele diplotype. The probability P (base allele|SV configuration, population) of the base star allele diplotype is calculated by dividing (i) the probability of a given pair of star alleles, hybrid alleles, or tandem alleles by (ii) the probability of all configurations containing the allele of interest.

[0157] Similar to the NR value discussed above, Figure 6 The BAF node 612 in is modeled as a Gaussian distribution:

[0158]

[0159] where the BAF mean and standard deviation are obtained from a clustering algorithm (e.g., GenTrain clustering) based on a set of training samples. The BAF probability P(BAF|base allele, sample error, systematic error) can be calculated based on the presence of sample and systematic errors in one of the following ways:

[0160] Method 1:

[0161] 1) If the sample Error = False, System Error = False:

[0162] BAF sd =BAF sd

[0163] P(sample Error ) = gs probability

[0164] P(System Error )=P(sample_variant_frequency)

[0165] 2) If the sample Error =True, System Error = False:

[0166] BAF sd =.1

[0167] P(sample Error )=1-gs probability

[0168] P(System Error )=P(sample_variant_frequency)

[0169] 3) If the sample Error =True, System Error =True:

[0170] Then P(BAF)=1

[0171] P(sample Error )=1-gs probability

[0172] P(System Error )=1-P(sample_variant_frequency)

[0173] -Select the minimum total cost of these three states as the state configuration and cost.

[0174] Method 2:

[0175] 1) If the sample Error = False, System Error = False:

[0176] BAF sd =BAF sd

[0177] P(sample Error ) = gs probability

[0178] P(System Error )=1

[0179] 2) If the sample Error =True, System Error = False:

[0180] BAF sd =.1

[0181] P(sample Error )=1-gs probability

[0182] P(System Error )=1

[0183] 3) If the sample Error =True, System Error =True:

[0184] Then P(sample Error )=1-gs probability

[0185] P(System Error )=1

[0186] P(variants present in the solution|system Error =True)=

[0187] variant_population_frequency

[0188] P(variant not in solution | system Error = true) = 1 -

[0189] variant_population_frequency

[0190] If P(BAF | no sample error) < 0.01 or there is a systematic error, then a sample error is determined to exist. If P(sample_variant frequency) < user_provided_threshold, then a systematic error is determined to exist. If a systematic error is detected, then the probability of the presence or absence of the variant of interest in the solution is determined based on the population frequency rather than P(BAF).

[0191] Figure 6 The sample error node 616 of represents the probability of a sample error and is 1 - gs_probability or gs_probability depending on the absence or presence of the sample error. gs_probability is the logit transformation of the GenCall score from the snv vcf file 1 / (1 + exp(-(GenCall score – 0.14)*140)). Note that 0.14 and 140 are only exemplary values; these parameters can be adjusted as needed for optimization purposes.

[0192] Occasionally, one or more variants in a batch of samples may be affected by genotyping batch effects or clustering errors. To detect this type of error, the frequency of the sample variants is compared to the known reference population frequency. Figure 6 The systematic error node 614 of represents the probability of a systematic error. The variant sample frequency can be compared to the population frequency to detect failed clusters.

[0193] Bayesian Graphical Model Likelihood:

[0194] The final (‘overall’) likelihood of each star allele call determined from the Bayesian graphical model is a composition (such as a sum) of the corresponding SV subnetwork log-likelihood of the call and the corresponding allele subnetwork log-likelihood.

[0195] As can be seen, from the above, a potential plurality of alternative calls may be generated, each with a corresponding overall likelihood. The plurality of possible calls may be output together with their likelihoods. Such output may optionally be provided as a ranking of those calls based on their likelihoods, and the ranking of the possible calls may be used in any desired manner (e.g., as desired for filtering purposes).

[0196] Table 1 below depicts exemplary results of various aspects described herein applied to the CYP2D6 PGx gene and is The results of CYP2D6 genotyping from whole genome sequencing (WGS) BAM files were compared using the NGS Star Allele Caller Tool (DRAGEN is a registered trademark of Illumina Inc.).

[0197]

[0198] Table 1

[0199] Observation has 9 samples of inconsistent star allele solutions between the NGS star allele caller tool and StARray:

[0200] For 3 samples, the next alternative StARray solution is The NGS Star Allele Caller tool is the same;

[0201] For 204619760003_R07C01 and 204619760012_R03C01, there are variants specific to CYP2D6*117 that are called with very high GS scores (0.7341 and 0.7339, respectively). The existing PGx caller and Starray in Illumina's array PGx analysis pipeline call *117, but NGS Star Allele Caller Tool does not have;

[0202] For 204619760008_R03C01, the variant associated with CYP2D6*22 was not genotyped in the array due to very low quality (e.g., GS score of ~0.03). The PGx caller in Illumina's array PGx analysis pipeline and Starray called this as *1 instead of CYP2D6*22 by NGS Star Allele Caller Tool;

[0203] For 204619760012_R08C01, there are more discrepancies in CNV calling. The CNV region that led to the inconsistent calling is CNV:CYP2D6.p5:chr22:42130886:42131379. This has a relatively high quality value of 28, making the existing Illumina array PGx analysis pipeline PGx caller and Starray comparable. NGS star allele caller tool slightly different copy numbers. (*4+*68 / *4 vs. *4+*68 / *4+*68);

[0204] For 204619760010_R07C01, the BAF value supports StARray calling two *90 alleles;

[0205] For 204619760005_R02C01, there are more discrepancies in the CNV calls. The CNV region that resulted in the inconsistent calls was CNV:CYP2D6.exon.9:chr22:42126498:42126752. This has a medium quality value of 19, making StARray have a similar quality to 204619760005_R02C01. NGS star allele caller tool slightly different copy numbers (*10,*36,*36,*36 vs. *10+*36 / *10+*36).

[0206] In some examples, the log-likelihood scores (e.g., the scores corresponding to each star allele call determined from the Bayesian graphical model) can be converted to a representation that is more convenient for interpretation, downstream usability, or other purposes. For example, the log-likelihood can be converted to a posterior probability by normalizing each score based on a score of a set of candidate solution scores (e.g., the sum of the scores of all candidate solutions) to produce a posterior probability value between 0 and 1. In some cases, this may be superior to the raw log-likelihood values.

[0207] In some examples, a caller for a single variant is implemented that identifies genotype variant calls from input single nucleotide variant data (e.g., snv.vcf) and computes the associated log-likelihood probability using a Bayesian graphical model as described above (but without the integer programming aspects) to report the log-likelihood of the variant call.

[0208] The processing results described herein can be output in any desired format. As described above, calls can be output with their likelihoods and sorted based on this. In an example, a set of candidate star allele solutions that may fit the array data and the sorting of those solutions can be output for each sample.

[0209] Figure 7A-7GDepicted are exemplary result outputs of candidate solutions according to various aspects described herein. In these examples, the output is provided in the form of a table / spreadsheet, where most rows correspond to samples and most columns correspond to different result data for each of those samples. The output can be displayed on a graphical user interface for user viewing and interaction. Figure 7A-7G Each of the figures in depicts a portion of an exemplary spreadsheet shown on a graphical user interface.

[0210] First reference Fig. 7A , 10 rows 702 of output are shown for illustration. The first two rows provide header information for the data, and the third row contains the title / name of each column. The fourth to tenth rows show partial results for 7 samples. In practice, the result output will typically include results for many more samples (e.g., hundreds or thousands of samples).

[0211] Different columns provide different types of result data. Fig. 7A Shown in FIG. 7 is data indicating the sample name 704, the determined sample rank 706, an indication of the gene or variant 708, the type 710, and the solution 712. Fig. 7A , row 6 corresponding to the CYP2D6 gene is highlighted.

[0212] Further details are in Figure 7B , which depicts additional columns for extracting length 714 data and supporting variant 716 data. Figure 7B In the row identified by 703 (corresponding to the CYP2D6 gene), the type 710 is appropriately represented as a haplotype. In this regard, the caller distinguishes between haplotype calls (eg, star alleles) and variant calls or 'simple variants'. Figure 7C An example row 705 of result data for a variant sample is depicted, in which a variant name is provided and the sample is identified as a simple variant.

[0213] Return to reference Figure 7B , particularly the results for the CYP2D6 gene sample, solution 712 provides a simple representation of the solution, which in this example indicates the complete allele (*161) and the tandem allele (*36x2+*10). Solution length 714 indicates a longer form of the solution, which conveys more detailed information about the structural variants (if applicable). For CYP2D6, this indicates "complete: *161, *36x2+*10" to indicate the complete *161 allele and the tandem allele *36x2+*10.

[0214] Supporting variants data 716 provides any reported supporting variants. For any given star allele identified, all variants may or may not be present in the array. Supporting variants 716 data reports the variants detected in the array. Reference Fig.7D , showing a part of 716 supporting variants of CYP2D6 gene and some key information about the variant. The reported variant begins with a variant corresponding to the *161 allele. The information provided includes (using the first reported variant in this example) chromosome location (22), position (42126611), reference value (C), variant value (G) and other information. In addition, the actual genotype (e.g., 1 / 1), GS score (1) and BAF value (1) found in the BCF file are provided, and the GS score is a score indicating the confidence of the variant call, and the BAF value is also used to determine whether the call made is accurate B allele frequency. The support information of the star allele provided by the caller can be very useful for debugging and other purposes.

[0215] refer to Fig. 7E , additional result information that may be useful for debugging (or other purposes) is the missing / masked core variant data 718, which provides any missing or masked core variants from the array. Using the CYP2D6 gene example from row 703, no variants are missing ("Complete: *161()"). Row 707, corresponding to the results for the CYP2C19 gene, indicates that the core variant identified by 717 is missing from the array. The results for supported variants and missing variants provide an easy way for the user to determine what is and is not present in the array to support the corresponding star allele call.

[0216] refer to Figure 7F , the column for all missing variants in array 718 reports all PGx-associated variants missing from the array (or filtered, e.g., from quality control processing due to low quality) and the star alleles potentially affected by them for the associated sample (here from row 719). As an example, the first variant reported corresponds to the *36 star allele, and the second variant corresponds to the *80 start allele.

[0217] like Figure 7G As shown, additional columns for collapsed star alleles 720, scores 722, raw scores 724, and copy number solutions 726 are provided. With respect to collapsed star alleles, it is sometimes difficult or impossible to distinguish one star allele from another when a deletion variant is present in the array. Therefore, the collapsed star allele data for each sample reports all star alleles that collapse into the same haplotype, listed starting with the most frequent star allele, followed by the least frequent / lower star alleles enclosed in parentheses. The data for the sample in row 721 indicates *1 as the most frequent star allele, but also indicates a less frequent *38 star allele.

[0218] Score data 722 and raw score data 714 present the Bayesian graphical model likelihood log-likelihood transformed into posterior probabilities and either (i) taking into account the population prior probabilities (presented as scores 722) or (ii) not taking into account the population prior probabilities (presented as raw scores 724). In either column, a higher value indicates a higher probability of the likelihood of the solution being called.

[0219] Copy number solution data 726 presents a prediction of the copy number of each exon and intron within the indicated gene.

[0220] Figure 7A-7G The resulting output is provided in the form of a table, but other formats are possible. Figure 8A-8B Depicts additional exemplary result outputs of candidate solutions according to various aspects described herein, and more particularly depicts a portion of the results output in JSON (JavaScript Object Notation) format. Figure 8A-8B The data provided in the JSON example is provided on a sample-by-sample basis. A portion of the JSON output for the CYP2C19 gene for one sample is given in Figure 8A-8B Shown in.

[0221] In addition, the data for each indicated star allele is annotated to indicate metabolizer status ("phenotype"). In the PGx space, two well-known public guidelines that include indications of metabolizer status are those issued by the Clinical Pharmacogenetics Implementation Consortium (CPIC) and the Dutch Pharmacogenetics Working Group (DPWG). The CPIC guidelines are used in this example, as an example, and include ultrafast, normal, intermediate, and poor metabolizer states.

[0222] The resulting output is presented in the form of fields / types along with the value of the field. Figure 8A-8B, the record shown indicates fields with corresponding values, including "Gene" indicating the CYP2C19 gene; "Call Type" indicating the star allele call; "Genotype" indicating the total genotype of "*1 / *2"; "Activity Score" assigned to the allele if present / applicable; and "Phenotype" indicating mapping to the "Intermediate Metabolizer" state. Additional fields corresponding to the fields discussed above are provided, including fields for scores ("Quality Score"), raw scores ("Raw Score"), supported variants ("Supported Variants"), and candidate solutions ("Candidate Solutions"). Regarding candidate solutions, data for two solutions is shown in this example to indicate two solutions with different star alleles (*1 / *2 vs. *15 / *2) in this example. The candidate solution section provides the highest ranked solutions (e.g., two in this example, but more may be provided). For each candidate solution, various information is provided, such as some or all of the information discussed above, such as genotype, activity score, phenotype, quality score, raw score, and allele information for various alleles, including solution length, supporting variants, missing variants, and folded allele information.

[0223] The overall "phenotype" (here "intermediate metabolizer") provided above the candidate solutions can be an aggregation of the phenotypes indicated for the individual candidate solutions; here, there is agreement between two different solutions corresponding to different genotypes but having a common phenotype ("intermediate metabolizer"). The overall phenotype used for calling in the case of different phenotypes in the solution can follow any desired method. As an example, one such method is to take the phenotype of the highest ranked solution.

[0224] Although not shown, as an example, additional information included in the JSON output for each gene could be a list of all missing variants and a list of alleles tested.

[0225] It can be seen that Figure 8A-8B The JSON output can include Figure 7A-7G The same information provided in the examples, plus other / additional information such as aggregating the call information to include e.g. mapped metabolizer states / phenotypes and activity scores.

[0226] JSON and similar formats can use syntax-based coloring for the different types of data included, such as providing data types / fields in one color and the values ​​of these fields in another color. Any other highlighting, coloring, or other visual indication can be used to distinguish some data from other data.

[0227] Figure 9A-9CDescribe the exemplary comparative results obtained from testing StARray method as herein described with conventional caller.Comparative results are presented in these figures in the form of table.Four different test data sets (#1, #2, #3 and #4) are used to test.The size range of data set is 142 samples (#2) to 1576 samples (#4), and Coriell cell line samples are used.Each data set is provided to conventional caller as input, and is provided to the caller realizing StARray method as herein described separately.

[0228] refer to Fig. 9A , the table includes six columns. From left to right, the first column identifies the dataset, the second column indicates the sample size of the dataset, the third and fourth columns indicate the number and call rate of no calls using the StARray method, and the fifth and sixth columns indicate the number and call rate of no calls using the StARray method. The call rate reflects samples run on the global diversity array with enhanced PGx and evaluated the CYP2D6 gene.

[0229] from Fig. 9A As can be seen from the results in , the StARray invoker provides a significant improvement over the conventional invoker in terms of a lower number of no-calls and therefore a higher call rate (and a lower no-call rate).

[0230] refer to Fig. 9B ,These results indicate consistency, and the array caller no call is included in the comparison.,The table includes nine columns:,From left to right, the first and second columns identify the dataset and,the sample size of the dataset, e.g. Fig. 9A As shown. The third column indicates the number of whole genome sequencing (WGS) references (comparisons) from the sample set. The fourth, fifth, and sixth columns indicate the number of 'exact matches' (i.e., the number of WGS references that the caller fully matches), consistency (exact matches divided by the number of WGS references), and calling accuracy of the StARray caller, respectively. The seventh, eighth, and ninth columns indicate the number of 'exact matches' (i.e., the number of WGS references that the caller fully matches), consistency (exact matches divided by the number of WGS references), and calling accuracy of the conventional caller, respectively. The consistency reflects samples run on a global diversity array with enhanced PGx and evaluated for the CYP2D6 gene. Not all samples have a whole genome sequencing (WGS) reference and / or were not called in the WGS data. From Fig. 9B As can be seen from the results in , the StARray caller provides significant improvements over the regular caller in terms of the number and consistency of exact matches.

[0231] refer to Fig. 9C,These results indicate the accuracy of the callers, and no calls are not included in the comparison.,The table includes eight columns:,From left to right, the first and second columns identify the dataset and,the sample size of the dataset, e.g. Fig. 9A and Fig. 9B The third, fourth and fifth columns indicate, respectively: the number of called diplotypes with WGS references for the StARray caller, the number of 'complete matches' (with Fig. 9B The sixth, seventh and eighth columns indicate, respectively: the number of called diplotypes with the WGS reference for the conventional caller, the number of 'exact matches' (with Fig. 9B The sixth column of ) and accuracy (number of exact matches divided by the number of called diplotypes). Accuracy reflects samples run on the Global Diversity Array with enhanced PGx and evaluated for the CYP2D6 gene. Likewise, not all samples had a whole genome sequencing (WGS) reference and / or were not called in the WGS data. Fig. 9C As can be seen from the results in , the StARray caller provides a significant improvement in accuracy over the conventional caller.

[0232] If desired, partial matches and mismatches may also be tracked, and an overall accuracy (combining the number of perfect matches, partial matches, and mismatches) may be determined.

[0233] therefore, Fig.10 Depicted are exemplary methods for star allele calling according to various aspects described herein, such as methods for determining star alleles of pharmacogenomics genes using high-throughput targeted genotyping. In one or more examples, the method can be performed by one or more processors or processing circuit systems of computers / computer systems such as those described herein. For example, implementing Fig.10 The code or instructions of the method may be part of a module of the software / computer program.

[0234] refer to Fig.10 , the method is based on the pharmacogenomic genotyping of the sample, and obtains (1002) input gene sequence variation data from a high-throughput genotyping platform. By way of example, the high-throughput genotyping platform includes a microarray-based genotyping platform. For example, the input gene sequence variation data may include genotype data and copy number variant call data. In some embodiments, the genotype data and copy number data include B allele frequency (BAF) and log R ratio data.

[0235] The method also applies (1004) a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample. For example, applying the Bayesian graphical model uses multi-solution integer programming to explore the model space of the Bayesian graphical model in (i) a first phase including structural variant (SV) candidate identification and (ii) a second phase including star allele candidate identification based on the SV candidate identification to determine the plurality of different star allele calls.

[0236] In an embodiment, the first stage identifies multiple SV candidates, and for each of the multiple SV candidates, the cost of the SV candidate is evaluated. For example, the cost of the SV candidate may include a logarithmic transformed likelihood. Multiple SV candidates that meet or exceed a predefined likelihood threshold in the multiple SV candidates may be output from the first stage to generate multiple SV candidates provided to the second stage. Constraints may be provided as part of the SV candidate identification to ensure that at least two SV candidates are provided to the second stage.

[0237] In embodiments, the second phase identifies multiple star allele candidates, and the cost of the star allele candidate is evaluated for each star allele candidate in the multiple star allele candidates. For example, the cost of the star allele candidate can include the likelihood through logarithmic transformation. Each star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model can correspond to the star allele candidate identified by the second phase and the corresponding SV candidate identified by the first phase. The corresponding quality score of the star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model can include the synthesis of the cost of the star allele candidate identified by the second phase and the cost of the SV candidate identified by the first phase (ii). For example, the synthesis can include the sum of the cost of the star allele candidate identified by the second phase and the cost of the SV candidate identified by the first phase.

[0238] continue Fig.10 , the method provides (1006) a corresponding quality score for each star allele call in the plurality of different star allele calls. In an embodiment, the Bayesian graphical model considers the quality and population frequency of the structural variant and the star allele when determining the corresponding quality score for each star allele call in the plurality of different star allele calls. In some examples, the corresponding quality score for each star allele call in the plurality of different star allele calls can include a log-transformed likelihood converted to a posterior probability.

[0239] The method can also provide (1008) for each of the plurality of different star allele calls one or more of: (i) supporting variants for the star allele call, (ii) missing and / or masked core variants, or (iii) missing pharmacogenomic-associated variants. Additionally, the method can rank (1010) the plurality of different star allele calls based on the corresponding quality scores of each of the plurality of different star allele calls.

[0240] The processes described herein may be performed by one or more computer systems, individually or collectively, such as one or more computer systems executing genome analysis software to perform various aspects described herein. Fig.11 Depicted are examples of computer systems and associated devices that incorporate and / or use the various aspects described herein. Computer systems may also be referred to herein as data processing devices / systems, computing devices / systems / nodes, or simply computers. Computer systems may be based on one or more of a variety of system architectures and / or instruction set architectures, such as those provided by Intel Corporation (Santa Clara, California, USA) as examples. Fig.11 A computer system 1100 is shown communicating with an external device 1112. The computer system 1100 includes one or more processors 1102, such as a central processing unit (CPU). The processor may include functional components used in instruction execution, such as obtaining program instructions from a location such as a cache or main memory, decoding program instructions and executing program instructions, accessing memory for instruction execution, and writing the results of the executed instructions. The processor 1102 may also include registers used by one or more of the functional components. The computer system 1100 also includes a memory 1104, an input / output (I / O) device 1108, and an I / O interface 1110, which may be coupled to the processor 1102 and to each other via one or more buses and / or other connections. The bus connection represents any one or more bus structures of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example and not limitation, such architectures include Industry Standard Architecture (ISA), Micro Channel Architecture (MCA), Enhanced ISA (EISA), Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI).

[0241] The memory 1104 may be or include a main or system memory (e.g., random access memory) used in the execution of program instructions, a storage device such as a hard drive, flash media, or optical media as examples, and / or a cache memory as examples. The memory 1104 may include, for example, a cache, such as a shared cache, which may be coupled to a local cache of the processor 1102 (examples include an L1 cache, an L2 cache, etc.). In addition, the memory 1104 may be or include at least one computer program product having a set (e.g., at least one) of program modules, instructions, codes, etc., which are configured to perform the functions of the embodiments described herein when executed by one or more processors.

[0242] The memory 1104 may store an operating system 1105 and other computer programs 1106, such as one or more computer programs / applications executed to perform the various aspects described herein. Specifically, the programs / applications may include computer-readable program instructions that may be configured to perform the functions of the embodiments of the various aspects described herein.

[0243] Examples of I / O devices 1108 include, but are not limited to, microphones, speakers, global positioning system (GPS) devices, cameras, lights, accelerometers, gyroscopes, magnetometers, sensor devices configured to sense light, proximity, heart rate, body temperature and / or ambient temperature, blood pressure, and / or skin resistance, and activity monitors. I / O devices can be incorporated into the computer system as shown, although in some embodiments, I / O devices can be viewed as external devices (1112) coupled to the computer system via one or more I / O interfaces 1110.

[0244] The computer system 1100 can communicate with one or more external devices 1112 through one or more I / O interfaces 1110. Exemplary external devices include keyboards, pointing devices, displays, and / or any other device that enables a user to interact with the computer system 1100. Other exemplary external devices include any device that enables the computer system 1100 to communicate with one or more other computing systems or peripherals, such as a printer. A network interface / adapter is an exemplary I / O interface that enables the computer system 1100 to communicate with one or more networks, such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet), thereby providing communication with other computing devices or systems, storage devices, etc. Ethernet-based interfaces (such as Wi-Fi) and The adapter is merely an example of a currently available type of network adapter used in computer systems (BLUETOOTH is a registered trademark of Bluetooth SIG, Inc., Kirkland, Washington, USA).

[0245] Communication between I / O interface 1110 and external device 1112 may occur across a wired and / or wireless communication link 1111, such as an Ethernet-based wired or wireless connection. Exemplary wireless connections include cellular, Wi-Fi, Proximity-based near-field or other types of wireless connections. More generally, the communication link 1111 may be any suitable wireless and / or wired communication link for transmitting data.

[0246] Specific external devices 1112 may include one or more data storage devices that may store one or more programs, one or more computer-readable program instructions and / or data, etc. Computer system 1100 may include and / or be coupled to and communicate with removable / non-removable, volatile / non-volatile computer system storage media (e.g., as an external device to the computer system). For example, the computer system may include and / or be coupled to a non-removable, non-volatile magnetic medium (commonly referred to as a "hard drive"), a disk drive for reading from and writing to a removable, non-volatile disk (e.g., a "floppy disk"), and / or an optical drive for reading from or writing to a removable, non-volatile optical disk such as a CD-ROM, DVD-ROM, or other optical media.

[0247] The computer system 1100 can operate with numerous other general or special computing system environments or configurations. The computer system 1100 can take any of a variety of forms, well-known examples of which include, but are not limited to, personal computer (PC) systems, server computer systems such as message servers, thin clients, fat clients, workstations, laptop computers, handheld devices, mobile devices / computers such as smart phones, tablet computers and wearable devices, multiprocessor systems, microprocessor-based systems, telephony devices, network appliances (such as edge appliances), virtualization devices, storage controllers, set-top boxes, programmable consumer electronics, network PCs, small computer systems, large computer systems, and distributed cloud computing environments including any of the above systems or devices, etc.

[0248] Aspects of the present invention may be systems, methods, and / or computer program products, any of which may be configured to perform or facilitate the aspects described herein.

[0249] In some embodiments, various aspects of the present invention can take the form of a computer program product, which can be embodied as a computer-readable medium. A computer-readable medium can be a tangible storage device / medium on which a computer-readable program code / instruction is stored. Exemplary computer-readable media include, but are not limited to, electronic, magnetic, optical or semiconductor storage devices or systems or any combination of the foregoing. Exemplary embodiments of computer-readable media include hard disk drives or other mass storage devices, electrical connections with wires, random access memories (RAMs), read-only memories (ROMs), erasable programmable read-only memories such as EPROMs or flash memories, optical fibers, portable computer disks / floppy disks such as compact disk read-only memories (CD-ROMs) or digital versatile disks (DVDs), optical storage devices, magnetic storage devices or any combination of the foregoing. Computer-readable media can be read by a processor, a processing unit, etc. to obtain data (e.g., instructions) from the medium for execution. In a specific example, a computer program product is or includes one or more computer-readable media, which include / store computer-readable program codes to provide and facilitate one or more aspects described herein.

[0250] As noted, the program instructions included or stored in / on a computer readable medium can be obtained and executed by any of the various suitable components such as a processor of a computer system, so that the computer system performs and operates in a particular manner. Such program instructions for performing operations to perform, realize or promote various aspects described herein can be written in any desired programming language, or compiled from the code written in any desired programming language. In some embodiments, such programming languages ​​include object-oriented and / or procedural programming languages ​​such as C, C++, C#, Java, etc.

[0251] Program code may include obtaining one or more program instructions for execution by one or more processors. Computer program instructions may be provided to one or more processors of, for example, one or more computer systems to produce a machine so that the program instructions perform, implement or facilitate various aspects of the present invention when executed by one or more processors, such as the actions or functions described in the flowcharts and / or block diagrams described herein. Therefore, in some embodiments, each frame or combination of frames of the flowchart illustrations and / or block diagrams depicted and described herein may be implemented by computer program instructions.

[0252] While various implementations are described above, these are merely examples.

[0253] The terms used herein are only for the purpose of describing specific embodiments and are not intended to be limiting. As used herein, unless the context clearly indicates otherwise, the singular forms "a", "an", and "the" are intended to also include plural forms. It should also be understood that when used in this specification, the terms "include" and / or "comprise" specify the presence of the features, integers, steps, operations, elements, and / or parts, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, parts, and / or groups thereof.

[0254] The corresponding structures, materials, actions, and equivalents of all means or steps plus functional elements in the following claims, if any, are intended to include any structure, material, or action for performing the function in combination with other claimed elements specifically claimed. The description of one or more embodiments has been presented for the purposes of illustration and description, but is not intended to be exhaustive or limited to the disclosed forms. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiments are selected and described in order to best explain the various aspects and practical applications, and to enable others of ordinary skill in the art to understand the various embodiments with various modifications suitable for the specific purposes contemplated.

Claims

1. A computer-implemented method comprising: Sample-based pharmacogenomic genotyping obtains input gene sequence variation data from a high-throughput genotyping platform; applying a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample; as well as Each star allele call in the plurality of different star allele calls is provided with a corresponding quality score.

2. The method of claim 1, wherein the high-throughput genotyping platform comprises a microarray-based genotyping platform.

3. The method according to claim 1 or 2, wherein the input gene sequence variation data comprises genotype data and copy number variant call data.

4. The method of claim 3, wherein the genotype data and the copy number data include B allele frequency (BAF) and log R ratio data.

5. The method of claim 1 , 2, 3 or 4, wherein the applying the Bayesian graphical model uses multi-solution integer programming to explore the model space of the Bayesian graphical model in (i) a first stage comprising structural variant (SV) candidate identification and (ii) a second stage comprising star allele candidate identification based on the SV candidate identification to determine the plurality of different star allele calls. The method of claim 5 , wherein the first stage identifies a plurality of SV candidates and evaluates a cost of the SV candidate for each of the plurality of SV candidates. The method of claim 6 , wherein the cost of the SV candidate comprises a log-transformed likelihood.

8. The method according to claim 6 or 7, wherein a plurality of SV candidates satisfying or exceeding a predefined likelihood threshold among the plurality of SV candidates are output from the first stage to generate a plurality of SV candidates provided to the second stage.

9. The method of claim 5, 6, 7 or 8, wherein constraints are provided as part of the SV candidate identification to ensure that at least two SV candidates are provided to the second stage.

10. The method of claim 5, 6, 7, 8 or 9, wherein the second stage identifies a plurality of star allele candidates and evaluates the cost of the star allele candidate for each of the plurality of star allele candidates.

11. The method of claim 10, wherein the cost of the star allele candidate comprises a log-transformed likelihood.

12. A method according to claim 10 or 11, wherein each star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model corresponds to a star allele candidate identified by the second stage and a corresponding SV candidate identified by the first stage, and wherein the corresponding quality scores of the star allele calls in the multiple different star allele calls determined by applying the Bayesian graphical model include (i) the cost of the star allele candidate identified by the second stage and (ii) the synthesis of the cost of the SV candidate identified by the first stage.

13. The method of claim 12, wherein the synthesis comprises the sum of the cost of the star allele candidates identified by the second stage and the cost of the SV candidates identified by the first stage.

14. The method of claim 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, or 13, wherein the Bayesian graphical model considers the quality and population frequency of structural variants and star alleles when determining the corresponding quality score for each star allele call in the plurality of different star allele calls.

15. The method of claim 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 or 14, further comprising ranking the plurality of different star allele calls based on the corresponding quality score of each of the plurality of different star allele calls.

16. The method of claim 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, or 15, wherein the corresponding quality score for each of the plurality of different star allele calls comprises a log-transformed likelihood converted to a posterior probability.

17. The method of claim 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 or 16, further comprising providing, for each of the plurality of different star allele calls, one or more of: (i) supporting variants for the star allele call, (ii) missing and / or masked core variants, or (iii) missing drug genome-associated variants.

18. A computer system, comprising: Memory; as well as a processor in communication with the memory, wherein the computer system is configured to perform a method comprising: Sample-based pharmacogenomic genotyping obtains input gene sequence variation data from a high-throughput genotyping platform; applying a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample; as well as Each star allele call in the plurality of different star allele calls is provided with a corresponding quality score.

19. The computer system of claim 18, wherein the high-throughput genotyping platform comprises a microarray-based genotyping platform.

20. The computer system of claim 18 or 19, wherein the input gene sequence variation data comprises genotype data and copy number variant call data.

21. The computer system of claim 20, wherein the genotype data and the copy number data include B allele frequency (BAF) and log R ratio data.

22. A computer system according to claim 18, 19, 20 or 21, wherein the application of the Bayesian graphical model uses multi-solution integer programming to explore the model space of the Bayesian graphical model in (i) a first stage including structural variant (SV) candidate identification and (ii) a second stage including star allele candidate identification based on the SV candidate identification to determine the multiple different star allele calls.

23. The computer system of claim 22, wherein the first stage identifies a plurality of SV candidates and evaluates a cost of the SV candidate for each of the plurality of SV candidates.

24. The computer system of claim 23, wherein the cost of the SV candidate comprises a log-transformed likelihood.

25. The computer system of claim 23 or 24, wherein a plurality of SV candidates that meet or exceed a predefined likelihood threshold among the plurality of SV candidates are output from the first stage to generate a plurality of SV candidates provided to the second stage.

26. A computer system according to claim 22, 23, 24 or 25, wherein constraints are provided as part of the SV candidate identification to ensure that at least two SV candidates are provided to the second stage.

27. The computer system of claim 22, 23, 24, 25 or 26, wherein the second stage identifies a plurality of star allele candidates and evaluates a cost of the star allele candidate for each of the plurality of star allele candidates.

28. The computer system of claim 27, wherein the cost of the star allele candidate comprises a log-transformed likelihood.

29. A computer system according to claim 27 or 28, wherein each star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model corresponds to a star allele candidate identified by the second stage and a corresponding SV candidate identified by the first stage, and wherein the corresponding quality scores of the star allele calls in the multiple different star allele calls determined by applying the Bayesian graphical model include (i) the cost of the star allele candidate identified by the second stage and (ii) the synthesis of the cost of the SV candidate identified by the first stage.

30. The computer system of claim 29, wherein the synthesis comprises the sum of the cost of the star allele candidates identified by the second stage and the cost of the SV candidates identified by the first stage.

31. A computer system according to claim 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 or 30, wherein the Bayesian graphical model considers the quality and population frequency of structural variants and star alleles when determining the corresponding quality score for each star allele call in the plurality of different star allele calls.

32. The computer system of claim 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, or 31, wherein the method further comprises ranking the plurality of different star allele calls based on the corresponding quality score of each of the plurality of different star allele calls.

33. A computer system according to claim 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 or 32, wherein the corresponding quality score of each star allele call in the plurality of different star allele calls comprises a log-transformed likelihood converted to a posterior probability.

34. According to claims 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 or 33, wherein the method further comprises providing, for each star allele call in the plurality of different star allele calls, one or more of: (i) supporting variants for the star allele call, (ii) missing and / or masked core variants, or (iii) missing drug genome-associated variants.

35. A computer program product, the computer program product comprising: A computer readable storage medium capable of being read by a processing circuit and storing instructions for execution by the processing circuit to perform a method comprising: Sample-based pharmacogenomic genotyping obtains input gene sequence variation data from a high-throughput genotyping platform; applying a Bayesian graphical model to determine a plurality of different star allele calls corresponding to the sample; and Each star allele call in the plurality of different star allele calls is provided with a corresponding quality score.

36. The computer program product of claim 35, wherein the high-throughput genotyping platform comprises a microarray-based genotyping platform.

37. A computer program product according to claim 35 or 36, wherein the input genetic sequence variation data includes genotype data and copy number variant call data.

38. The computer program product of claim 37, wherein the genotype data and the copy number data include B allele frequency (BAF) and log R ratio data.

39. A computer program product according to claim 35, 36, 37 or 38, wherein the application of the Bayesian graphical model uses multi-solution integer programming to explore the model space of the Bayesian graphical model in (i) a first stage including structural variant (SV) candidate identification and (ii) a second stage including star allele candidate identification based on the SV candidate identification to determine the multiple different star allele calls.

40. The computer program product of claim 39, wherein the first stage identifies a plurality of SV candidates and evaluates, for each SV candidate of the plurality of SV candidates, a cost of the SV candidate.

41. The computer program product of claim 40, wherein the cost of the SV candidate comprises a log-transformed likelihood.

42. A computer program product according to claim 40 or 41, wherein a plurality of SV candidates among the plurality of SV candidates that meet or exceed a predefined likelihood threshold are output from the first stage to generate a plurality of SV candidates provided to the second stage.

43. A computer program product according to claim 39, 40, 41 or 42, wherein constraints are provided as part of the SV candidate identification to ensure that at least two SV candidates are provided to the second stage.

44. A computer program product according to claim 39, 40, 41, 42 or 43, wherein the second stage identifies a plurality of star allele candidates and evaluates the cost of the star allele candidate for each of the plurality of star allele candidates.

45. The computer program product of claim 44, wherein the cost of the star allele candidate comprises a log-transformed likelihood.

46. ​​A computer program product according to claim 44 or 45, wherein each star allele call in the multiple different star allele calls determined by applying the Bayesian graphical model corresponds to a star allele candidate identified by the second stage and a corresponding SV candidate identified by the first stage, and wherein the corresponding quality scores of the star allele calls in the multiple different star allele calls determined by applying the Bayesian graphical model include (i) the cost of the star allele candidate identified by the second stage and (ii) the synthesis of the cost of the SV candidate identified by the first stage.

47. The computer program product of claim 46, wherein the synthesis comprises the sum of the cost of the star allele candidates identified by the second stage and the cost of the SV candidates identified by the first stage.

48. A computer program product according to claim 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46 or 47, wherein the Bayesian graphical model considers the quality and population frequency of structural variants and star alleles when determining the corresponding quality score for each star allele call in the plurality of different star allele calls.

49. A computer program product according to claim 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47 or 48, wherein the method further comprises ranking the multiple different star allele calls based on the corresponding quality score of each star allele call in the multiple different star allele calls.

50. A computer program product according to claim 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48 or 49, wherein the corresponding quality score of each star allele call in the plurality of different star allele calls comprises a log-transformed likelihood converted to a posterior probability.

51. A computer program product according to claim 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 or 50, wherein the method further comprises providing one or more of the following for each star allele call in the multiple different star allele calls: (i) supporting variants for the star allele call, (ii) missing and / or masked core variants, or (iii) missing drug genome-associated variants.

Images