Добавил:
Sekretar
kiopkiopkiop18@yandex.ru
t.me/Prokururor I Вовсе не секретарь, но почту проверяю
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Ординатура / Хирургия / Библиотека им академика М.И. Перельмана / Книга_5529_Библиотеки_им_академика_М_И_Перельмана
.pdf
214 Bioinformatics of Autoimmune Diseases
6.4.5 BASE RECALIBRATION
def base_recalibration(sample_name, dedup_bam,
ref_genome, known_sites_vcf, output_dir):
os.makedirs(output_dir, exist_ok=True)
recal_table = os.path.join(output_dir, f"{sample_name}_recal_data.table")
recal_bam = os.path.join(output_dir, f"{sample_name}_recal.bam")
run_command(
f"gatk BaseRecalibrator "
f"-I {dedup_bam} "
f"-R {ref_genome} "
f"--known-sites {known_sites_vcf} "
f"-O {recal_table}"
)
run_command(
f"gatk ApplyBQSR "
f"-I {dedup_bam} "
f"-R {ref_genome} "
f"--bqsr-recal-file {recal_table} "
f"-O {recal_bam}"
)
return recal_bam
The base _ recalibration function is a key quality enhancement step in the variant calling
pipeline that improves the accuracy of base quality scores assigned by the sequencing instrument.
It takes in the sample name, a deduplicated BAM le, the reference genome, a known sites VCF le
(typically containing validated variant positions like those from dbSNP), and an output directory.
The function ensures that the output directory exists and prepares two key output les: a recalibration table and a recalibrated BAM le.
The rst part of the function runs GATK’s BaseRecalibrator, which analyzes the patterns
of systematic errors in the base quality scores across the sequencing data. It does this by comparing
observed bases in the BAM le to known variants provided in the VCF le, calculating empirical
quality score adjustments based on mismatches that are not explained by true variants. This generates a recalibration table capturing the necessary corrections.
The second command, ApplyBQSR , applies the calculated adjustments from the recalibration
table to the original deduplicated BAM le, producing a new BAM le with recalibrated base quality scores. These improved scores are crucial for downstream analysis because they directly inuence the condence assigned to each base during variant calling. Inaccurate quality scores can lead
to false positives or false negatives, so recalibration ensures a more trustworthy set of base calls. As
a result, this step signicantly enhances the reliability of variant detection, particularly in pipelines
using tools like GATK’s HaplotypeCaller, which depend on high-quality base information for
identifying true genetic variants.
The dbSNP-known sites, which are used as input, are essential resources used in variant calling
pipelines with GATK 4, particularly for base quality score recalibration (BQSR) and variant ltration. These les contain known polymorphic sites that help distinguish real biological variation
from sequencing or alignment artifacts. For human genome builds such as GRCh38 (hg38), GATK
recommends using curated VCF les derived from dbSNP and other public datasets.
One commonly used VCF le is the h ap m ap _ 3.3.h g38.vcf.g z, which includes SNPs collected from the International HapMap Project, version 3.3, and lifted over to the human genomebuild GRCh38 (hg38). It contains a set of well-characterized SNPs that are considered to be of high
condence and biologically validated across multiple human populations. This le is suitable for
GATK’s BQSR and variant recalibration steps, helping to model sequencing errors based on a reliable set of known variants.
215 Variant Analysis
Another important le is the 1000G _ phase1.snps.high _ confidence.hg38.vcf.gz,
which includes high-condence SNPs from the 1000 Genomes Project Phase 1. This le contains
well-validated variants and is used to improve the accuracy of VQSR. These les can be downloaded from the Broad Institute’s GATK resource bucket at the following URL:
https://storage.googleapis.com/genomics-public-data/resources/broad/hg38/
v0/
6.4.6 VARIANT CALLING
def haplotype_caller(sample_name, recal_bam, ref_genome, output_dir):
os.makedirs(output_dir, exist_ok=True)
gvcf = os.path.join(output_dir, f"{sample_name}.g.vcf.gz")
run_command((
f"gatk HaplotypeCaller "
f"-R {ref_genome} "
f"-I {recal_bam} "
f"-O {gvcf} "
f"-ERC GVCF"
))
return gvcf
The haplotype _ caller function performs one of the most critical steps in the variant call-
ing pipeline: the identication of genetic variants such as SNPs and small insertions or deletions
(indels). It takes a sample name, a recalibrated BAM le, a reference genome, and an output directory as input. The function begins by ensuring the output directory exists and then constructs the
path for the output le in the GVCF format, which is a compressed VCF le that includes not only
variant calls but also reference condence information for each genomic position.
The function executes the GATK HaplotypeCaller tool, a highly accurate and widely used
variant caller developed by the Broad Institute. By supplying the reference genome and the recalibrated BAM le, HaplotypeCaller analyzes the aligned reads to identify regions of variation. It
uses a local de novo assembly approach to better resolve complex regions of the genome and outputs
results in the GVCF format using the -ERC GVCF option. This format is particularly useful for
large-scale studies involving multiple samples, as it enables efcient joint genotyping in a later step
of the pipeline.
The output of this function, the GVCF le, serves as the intermediate representation of variant calls for a single sample. It provides both variant and non-variant positions, allowing multiple
GVCFs to be later merged and jointly genotyped across a cohort. This step ensures that variants are
called consistently across samples and lays the groundwork for accurate population-level variant
discovery. Therefore, haplotype _ caller is essential not only for generating per-sample vari-
ant calls but also for setting the stage for robust multi-sample analysis.
6.4.7 MERGING SAMPLE GENOTYPING
def joint_genotyping(gvcf_list, ref_genome, output_dir):
os.makedirs(output_dir, exist_ok=True)
merged_gvcf = os.path.join(output_dir, "cohort.g.vcf.gz")
vcf_output = os.path.join(output_dir, "cohort.vcf.gz")
inputs = ' '.join([f"--variant {gvcf}" for gvcf in gvcf_list])
run_command(
f"gatk CombineGVCFs -R {ref_genome} "
f"{inputs} -O {merged_gvcf}"
)
216 Bioinformatics of Autoimmune Diseases
run_command(
f"gatk GenotypeGVCFs -R {ref_genome} "
f"-V {merged_gvcf} -O {vcf_output}"
)
return vcf_output
The joint _ genotyping function is a crucial component of the variant calling pipeline,
responsible for integrating individual sample data into a unied, cohort-level variant call set. It takes
a list of GVCF les (each containing variant and non-variant site information for a single sample), a
reference genome, and an output directory. The function ensures the output directory exists and then
denes paths for intermediate and nal output les: a merged GVCF and a nal multi-sample VCF.
The function begins by using GATK’s CombineGVCFs tool to merge all individual GVCFs into
a single cohort GVCF. This step does not perform genotyping yet; it simply combines the variant
likelihoods and reference condence information from each sample into a single le. The combined
GVCF captures the complete variant context across the cohort, enabling subsequent analysis to
consider the population-wide evidence for variation at each genomic site.
After merging, the function calls GATK’s GenotypeGVCFs to perform joint genotyping. This
tool analyzes all candidate variant sites across the cohort, taking into account information from each
sample, and assigns genotypes accordingly. The result is a standard, indexed VCF le containing
high-condence variant calls across all samples in the study. This step is particularly important in
population-scale studies, as it improves variant detection sensitivity and specicity by leveraging the
collective data from multiple individuals. It helps avoid missing variants present at low frequencies
and ensures consistent genotyping across the entire dataset. As a result, joint _ genotyping
enhances both the accuracy and completeness of the nal variant dataset, forming the basis for
downstream analyses such as association studies, population genetics, and clinical interpretation.
6.4.8 VARIANT FILTERING
def filter_variants(vcf_file, ref_genome, output_dir):
os.makedirs(output_dir, exist_ok=True)
filtered_vcf = os.path.join(output_dir, "filtered_variants.vcf.gz")
run_command(
f"gatk VariantFiltration "
f"-R {ref_genome} "
f"-V {vcf_file} "
f"-O {filtered_vcf} "
f"--filter-expression 'QD < 2.0 || FS > 60.0 || MQ < 40.0' "
f"--filter-name 'GATK_Hard_Filter'"
)
return filtered_vcf
The filter _ variants function is an essential step in rening the results of variant calling
by applying quality lters to remove potentially unreliable variant calls. It takes a VCF le containing the raw variants from joint genotyping, a reference genome, and an output directory as input.
The function begins by ensuring the output directory exists, then denes the output path for the
ltered variant le, which will be saved in compressed VCF format.
This function uses GATK’s VariantFiltration tool to apply hard lters based on specic
annotation metrics. The ltering expression “QD < 2.0 || FS > 60.0 || MQ < 40.0” targets variants
with low quality-by-depth (QD), high strand bias (FS), or low mapping quality (MQ). These metrics
are critical indicators of variant reliability: low QD suggests that the variant is supported by few
reads relative to depth; high FS may indicate sequencing artifacts due to biased read orientation; and
low MQ suggests that reads supporting the variant are not condently aligned. Variants meeting any
of these criteria are tagged with the label GATK _ Hard _ Filter in the resulting VCF.
217 Variant Analysis
The impact of this function on the variant calling pipeline is signicant. While previous steps
focus on identifying potential variants, this stage helps differentiate between high-condence
variants and those more likely to be false positives. By agging or ltering low-quality variants,
this function enhances the reliability and interpretability of the nal variant dataset. This, in
turn, ensures that downstream analyses, whether clinical interpretation, functional annotation, or
population-level studies, are based on robust and credible genetic data.
6.4.9 ANNOTATION
VCF annotation with ANNOVAR is a crucial step in the analysis of genetic variants, especially
when working with complex diseases such as autoimmune disorders. The VCF is the standard way
to store genetic variants discovered through next-generation sequencing, including SNPs, insertions, and deletions. While the VCF le provides the raw genomic coordinates and allele changes,
it does not inherently include any functional interpretation or biological context. This is where
ANNOVAR becomes indispensable. ANNOVAR allows researchers to annotate these variants with
a wide range of information, enabling deeper biological understanding and prioritization of variants
for downstream research or clinical interpretation.
In the context of autoimmune diseases, which often involve complex, polygenic risk proles,
variant annotation serves to highlight those mutations that may inuence immune function, gene
regulation, or inammatory pathways. ANNOVAR supports the integration of multiple databases
that enrich variant data with functional, clinical, and population-level annotations. For example, the
refGene database is used to determine the gene-based context of each variant, whether it lies in an
exon, intron, splice site, UTR, or intergenic region. This is critical in autoimmune studies where
variants in immune-regulatory genes like HLA, PTPN22, or STAT4 are often involved. If a variant
falls within an exon, refGene can also determine the specic coding consequence, such as whether
it is a synonymous or nonsynonymous change.
The avs np151 database links variants to known dbSNP identiers. This information is useful for
identifying common polymorphisms versus novel or rare variants. In autoimmune research, this can
help differentiate between well-characterized population variants and those potentially involved
in disease-specic pathways. The clinvar_20240611 database provides clinical signicance classications for known variants, such as “Pathogenic”, “Likely pathogenic”, “Benign”, or “Uncertain
signicance”. Variants associated with monogenic immune disorders or known immune-regulatory
pathways can sometimes appear in ClinVar, giving direct clinical insight into relevance for autoimmune phenotypes.
The dbNSFP database (specically version 4.7c used here) aggregates predictive scores from
multiple tools such as SIFT and PolyPhen2. These scores assess the functional impact of nonsynonymous SNVs, offering insight into whether an amino acid substitution is likely to disrupt protein
function. For autoimmune diseases, where many susceptibility genes encode signaling molecules or
transcription factors, these predictions can guide the identication of potentially deleterious mutations affecting key immune mechanisms. Finally, COSMIC70 provides a cancer-centric database of
somatic mutations but is also valuable in autoimmune disease research due to the overlap in some
pathways between autoimmunity and oncogenesis, particularly in genes involved in immune surveillance, apoptosis, and cellular proliferation.
Together, these annotations provide a layered and multidimensional perspective on each variant.
In the case of autoimmune disease studies, this might mean identifying a rare missense variant in
an interleukin receptor gene, agged by dbNSFP as damaging and found to be clinically signicant
in ClinVar. Additionally, the ability to summarize and reformat annotation outputs enables easier
comparison across patients and integration with statistical models for association studies. As autoimmune diseases often involve both rare and common variants acting in concert, this systematic
annotation process is essential for discovering meaningful biological signals hidden within highthroughput genomic data.
218 Bioinformatics of Autoimmune Diseases
Installing ANNOVAR is a relatively straightforward process, but it requires a few manual steps
because the software is distributed in a controlled manner and not through typical package managers like pip or conda. To begin, users must visit the ofcial ANNOVAR website at http://www.
openbioinformatics.org/annovar/annovar _ download _ form.php and complete
a short registration form. This form includes providing a valid email address and agreeing to the
terms of use. After submitting the form, the website grants access to download the ANNOVAR
package, which comes as a compressed .tar.gz le. Once downloaded, the le can be extracted
using the tar command in Linux or macOS, or with software like 7-Zip on Windows. The extraction will create a directory containing several Perl scripts such as convert2annovar.pl and
table _ annovar.pl, which are the primary tools for converting and annotating variant les.
To use ANNOVAR, the system must have Perl installed, which is generally pre-installed on
Unix-based systems. There is no need for compilation or installation beyond placing the ANNOVAR
directory in a suitable location and ensuring the Perl scripts are executable. Users may choose to
add the ANNOVAR directory to their system’s PATH variable for convenience. It is also advisable
to test the installation by running a basic help command, such as Perl table _ annovar.pl, to
ensure the script executes and lists its options correctly.
Downloading the ANNOVAR human annotation databases is done using the included script
annotate _ variation.pl. This script automates the download of various genomic databases
to a specied directory. For example, to download the RefGene database for the human genome
build hg38, one would use the command:
perl annotate_variation.pl \
-buildver hg38 \
-downdb -webfrom annovar refGene humandb/
In this command, -buildver hg38 species the human genome version, -downdb instructs
the script to download a database, and humand b/ is the local directory where the downloaded les
will be stored. ANNOVAR supports both hg19 and hg38 builds, so users should be consistent with
the build version used throughout their analysis.
To download additional databases such as ClinVar, dbSNP, dbNSFP, or COSMIC, similar commands can be issued, substituting the appropriate database name. For instance, to get the latest
ClinVar database, the command would be
perl annotate_variation.pl \
-buildver hg38 \
-downdb clinvar_20240611 humandb/
Some databases like dbNSFP are large and compressed and may require manual decompression after download. Also, some versions of dbNSFP are not downloadable via the web interface
and must be obtained separately from their own repositories, followed by manual integration into
ANNOVAR’s humandb d irector y.
Once all required databases are downloaded and stored in the correct location, ANNOVAR is
ready for use in annotating human variants. The databases can be updated periodically using the
same annotate _ variation.pl script to ensure that the annotations reect the most recent
biological knowledge and variant classications. This setup allows researchers to run comprehensive variant annotations on local machines without the need for internet access during analysis,
which is especially useful in secure or clinical environments.
The annotation program “anno _ annovar.py” is a comprehensive and automated pipe-
line designed to process and annotate genetic variants stored in compressed VCF les using
ANNOVAR. It streamlines the entire workow from extracting raw .v cf.g z les, converting
them into ANNOVAR’s .avin p ut format, performing variant annotation using multiple curated
databases, and then formatting the results for downstream analysis. Designed with modularity and
219 Variant Analysis
scalability in mind, the program incorporates robust logging, parallel processing to handle multiple
samples efciently, and basic quality control to summarize key variant statistics. It is particularly
suitable for large-scale genomic studies, including research on autoimmune diseases, where highthroughput data requires structured, reproducible, and informative variant annotation to identify
clinically or biologically signicant mutations. The following provides a detailed description of
each function used in the annotation program.
def extract_vcf(file_path, output_dir):
file_name = os.path.basename(file_path).replace('.vcf.gz', '.vcf')
extracted_file_path = os.path.join(output_dir, file_name)
with gzip.open(file_path, 'rt') as f_in,
open(extracted_file_path, 'w') as f_out:
shutil.copyfileobj(f_in, f_out)
return extracted_file_path
The extract _ vcf function takes a compressed VCF le (.v c f.g z) and decompresses it into
a standard .v c f le. It uses Python’s gzip module to read the compressed le in text mode and
writes the output into a specied directory. This step is essential because ANNOVAR’s conversion
tool does not support compressed VCF les directly. By automating the extraction, the function
ensures the workow can handle raw input data generated by most variant callers.
def convert_vcf_to_annovar_input(vcf_file, annovar_path, output_dir):
"""Converts a VCF file to ANNOVAR input format."""
avinput_file = vcf_file.replace('.vcf', '.avinput')
avinput_file_path = os.path.join(output_dir,
os.path.basename(avinput_file))
cmd = [
"perl", os.path.join(annovar_path, "convert2annovar.pl"),
"-format", "vcf4", vcf_file, ">", avinput_file_path
]
subprocess.run(" ".join(cmd), shell=True)
return avinput_file_path
The convert _ vcf _ to _ annovar _ input function converts a standard .v c f le into
the ANNOVAR .avin p ut format. This conversion is done using the ANNOVAR utility script
convert2annovar.pl, with the -for mat v cf4 ag to specify the input type. The function
avoids shell-specic redirection by capturing the standard output directly into a le using Python’s
subprocess module. This conversion is necessary because the subsequent annotation step with
ANNOVAR requires input in .avinput format.
def annotate_with_annovar(avinput_file, annovar_path,
humandb_path, output_dir):
output_prefix = os.path.join(output_dir,
os.path.basename(avinput_file).replace('.avinput',
'_annovar'))
# List of ANNOVAR databases to use for annotation
databases = ["refGene","avsnp151","clinvar_20240611",
"dbnsfp47c","cosmic70"]
# Create the ANNOVAR annotation command
cmd = [
"perl", os.path.join(annovar_path, "table_annovar.pl"),
avinput_file, humandb_path,
"-buildver", "hg38",
"-out", output_prefix,
220 Bioinformatics of Autoimmune Diseases
"-remove", "-protocol", ",".join(databases),
"-operation", "g,f,f,f,f", "-nastring", ".", "-csvout"
]
subprocess.run(cmd)
csv_file = output_prefix + ".hg38_multianno.csv"
print(f"Annotation complete for {avinput_file}. Output: {csv_file}")
The annotate _ with _ annovar function performs the core annotation task. It constructs
and executes a command that runs table _ annovar.pl, which queries a list of annotation
databases, including refGene, avsnp151, clinvar_20240611, dbnsf p47c, and cosmic70. These data-
bases collectively provide functional information, known SNP IDs, clinical signicance, functional
prediction scores, and cancer mutation data. The output is a .cs v le with a multi-annotation summary for each variant. This annotated output is crucial for downstream biological interpretation and
clinical ltering of genetic variants.
def reformat_csv(input_file, output_file, num_columns=18):
with open(input_file, 'r', newline='', encoding='utf-8') as infile:
reader = csv.reader(infile)
rows = list(reader)
with open(output_file, 'w', newline='', encoding='utf-8') as outfile:
writer = csv.writer(outfile)
for row in rows:
# Ensure the row has the specified number of columns
if len(row) < num_columns:
# Add empty strings to make up the required number of columns
row.extend([''] * (num_columns - len(row)))
elif len(row) > num_columns:
row = row[:num_columns]
# Write the adjusted row to the output file
writer.writerow(row)
print(f"Reformatted CSV file saved to {output_file}")
The reformat _ csv function post-processes the output .csv le from ANNOVAR to ensure
consistency in the number of columns across all rows. This is particularly useful when integrating
outputs from multiple samples, or when formatting is inconsistent due to variable-length annotations. The function pads or truncates rows to ensure uniform structure, which helps when importing
into spreadsheet programs or parsing with pandas Python library for downstream analysis.
The summarize _ csv function provides a quick overview of the contents of each annotated
le. It reads the reformatted .c sv using pandas and reports the total number of variants. If the column CLNSIG (clinical signicance from ClinVar) is present, it also counts how many variants are
annotated as “Pathogenic”. This lightweight QC report helps identify samples with potential clinical
relevance or anomalies in variant burden.
The process _ file function is a wrapper that coordinates the full annotation pipeline for
one input le. It sequentially calls the extract, convert, annotate, reformat, and summarize functions
for a given .vc f.g z le. Exception handling is built in to ensure that errors in processing one le do
not halt the entire batch run. This function is designed to be used in parallel by the main controller.
The main function in the program sets the paths for input and output directories, along with the
ANNOVAR software and database locations. It gathers all .v cf.g z les in the input directory and
processes them using Python’s ProcessPoolExecutor to parallelize the annotation workow.
This setup ensures scalability for batch analysis of multiple samples, reducing the total processing
time signicantly.
Table 6.2 illustrates a few annotated variants: one in EGFR with a known missense mutation
labeled pathogenic, one in TP53 as a stopgain variant with oncogenic relevance, and another in
Variant Analysis 221
TABLE 6.2
ANNOVAR Annotation
Chr Start End Ref Alt Func.
refGene
7 140453136 140453136 A T Exonic EGFR missense_ rs121913421 Pathogenic D D COSM6224
17 7579472 7579472 G A Exonic TP53 stopgain rs28934578 Pathogenic D D COSM10719
12 25398284 25398284 G C Intronic KRAS . rs112445441 Benign T B .
Gene.
refGene
ExonicFunc.
refGene
variant
avsnp151 CLNSIG SIFT_
pred
Polyphen2_
HDIV_pred
Cosmic70_ID
KRAS that is likely benign. The annotations provide essential clues for understanding the functional impact of variants and guiding downstream validation or clinical decisions.
6.5 SUMMARY
This chapter offers a comprehensive and methodical exploration of variant analysis with a focus on
autoimmune diseases, integrating both biological context and computational methodology. It opens
by highlighting the central role of genetic variation, ranging from SNPs and CNVs to structural
and non-coding variants, in the pathogenesis of autoimmune disorders. These variants affect gene
expression, immune regulation, and tolerance, often contributing in nuanced ways to disease susceptibility. Key examples include the PTPN22 SNP rs2476601 in RA and type 1 diabetes, FCGR3B
CNVs in lupus, and non-coding enhancer variants near IL2RA in MS and type 1 diabetes. Somatic
mutations and PRS also receive attention for their emerging relevance in late-onset or complex autoimmune conditions. The chapter underscores the importance of integrative genomics, combining
GWAS, epigenetics, and functional databases to elucidate the impact of variants.
The core of the chapter delves into the technical framework of variant calling using highthroughput sequencing data. It outlines the pipeline from raw data generation to annotated variant
output, emphasizing best practices in read quality control, reference genome alignment, duplicate
removal, base recalibration, and variant identication—using tools like GATK HaplotypeCaller.
Detailed discussion of le formats such as VCF and BAM reects the rigor of computational standards required for variant detection. The text makes clear that the accuracy of variant calling is
deeply inuenced by experimental design, sequencing depth, genomic complexity, and preprocessing steps. Filtering techniques, such as GATK’s VQSR, are critical in distinguishing true variants
from artifacts. The chapter also underscores the value of combining DNA- and RNA-based variant calling to provide functional context, especially for assessing splicing defects or allele-specic
expression patterns.
Emphasizing its relevance to autoimmune disease research, the chapter discusses specic challenges and priorities in this eld. It highlights the need for high coverage in complex immune loci
like HLA, strategies to identify rare and low-frequency variants, and the importance of variant
annotation tools such as ANNOVAR and SnpEff. Annotation is shown to be central in bridging the
gap between raw genomic coordinates and biological interpretation, especially when drawing from
databases like dbSNP, ClinVar, gnomAD, and disease-focused repositories. These resources help
classify variants by predicted impact, pathogenicity, and known clinical associations. Integrating
annotations with metadata and functional genomics data strengthens genotype–phenotype correlations and supports the development of PRS and personalized medicine approaches.
The chapter concludes with a practical implementation of a variant calling pipeline using Python,
reecting a modular and reproducible approach to real-world data analysis. Each step of the pipeline, from downloading a reference genome to nal annotation using ANNOVAR, is described in
code and explained in context. This not only demonstrates technical uency but also provides a template for researchers seeking to build or adapt their own workows. The pipeline supports parallel
222 Bioinformatics of Autoimmune Diseases
processing and robust logging, allowing for scalable batch analysis of large sample cohorts, which
is increasingly necessary in population-scale autoimmune studies.
Altogether, this chapter blends biological insight with computational precision to offer a holistic
and inclusive view of variant calling in autoimmune disease research. It serves both as a foundational guide to understanding how genetic variation contributes to autoimmunity and as a practical
resource for implementing modern sequencing analysis pipelines. Through its clear structure and
comprehensive content, the chapter supports readers in navigating the complexities of variant detection and interpretation in the era of precision medicine.
BIBLIOGRAPHY
Abecasis, G. R., Altshuler, D. M., Auton, A., Brooks, L. D., DePristo, M. A., Durbin, R. M., Handsaker, R. E.,
Kang, H. M., Marth, G. T., McVean, G. A., & 1000 Genomes Project Consortium. (2012). An integrated
map of genetic variation from 1,092 human genomes. Nature, 491(7422), 56–65. https://doi.org/10.1038/
nature11632
Andrews, S. (2010). FastQC: A quality control tool for high throughput sequence data [Computer software].
Babraham Bioinformatics. http://www.bioinformatics.babraham.ac.uk/projects/fastqc/
Auton, A., Abecasis, G. R., Altshuler, D. M., Durbin, R. M., & 1000 Genomes Project Consortium. (2015).
A global reference for human genetic variation. Nature, 526(7571), 68–74. https://doi.org /10.1038/
nature15393
Broad Institute. (2025). Genome Analysis Toolkit (GATK) [Computer software]. https://gatk.broadinstitute.
org/
DePristo, M. A., Banks, E., Poplin, R., Garimella, K. V., Maguire, J. R., et al. (2011). A framework for varia-
tion discovery and genotyping using next-generation DNA sequencing data. Nature Genetics, 43(5),
491–498. https://doi.org/10.1038/ng.806
Ismail, H. D. (2022). Bioinformatics: A practical guide to NCBI databases and sequence alignments (1st ed.).
Chapman and Hall/CRC. https://doi.org/10.1201/9781003226611.
Ismail, H. D. (2023). Bioinformatics: A practical guide to next generation sequencing data analysis (1st ed.).
Chapman and Hall/CRC. https://doi.org/10.1201/9781003355205.
Karczewski, K. J., Francioli, L. C., et al. (2020). The mutational constraint spectrum quantied from variation
in 141,456 humans. Nature, 581(7809), 434–443. https://doi.org/10.1038/s41586-020-2308-7
Kuleshov, M. V., Jones, M. R., Rouillard, A. D., Fernández, N. F., Duan, Q., et al. (2016). Enrichr: a com-
prehensive gene set enrichment analysis web server 2016 update. Nucleic Acids Research, 44(W1),
W90–W97. https://doi.org/10.1093/nar/gkw377
Lek, M., et al. (2016). Analysis of protein-coding genetic variation in 60,706 humans. Nature, 536(7616),
285–291. https://doi.org/10.1038/nature19057
Li, H., & Durbin, R. (2009). Fast and accurate short read alignment with Burrows-Wheeler transform.
Bioinformatics, 25(14), 1754–1760. https://doi.org/10.1093/bioinformatics/btp324
McKenna, A., Hanna, M., Banks, E., Sivachenko, A., et al. (2010). The Genome Analysis Toolkit: A
MapReduce framework for analyzing next-generation DNA sequencing data. Genome Research, 20(9),
1297–1303. https://doi.org/10.1101/gr.107524.110
Peterson, T. A., Doughty, E., & Kann, M. G. (2013). Towards precision medicine: advances in computa-
tional approaches for the analysis of human variants. Journal of Molecular Biology, 425(21), 4047–4063.
https://doi.org/10.1016/j.jmb.2013.08.008
Quinlan, A. R., & Hall, I. M. (2010). BEDTools: a exible suite of utilities for comparing genomic features.
Bioinformatics, 26(6), 841–842. https://doi.org/10.1093/bioinformatics/btq033
Robinson, J. T., et al. (2011). Integrative genomics viewer. Nature Biotechnology, 29(1), 24–26. https://doi.
org/10.1038/nbt.1754
Van der Auwera, G. A., Carneiro, M. O., Hartl, C., Poplin, R., del Angel, G., et al. (2013). From FastQ data to
high-condence variant calls: the Genome Analysis Toolkit best practices pipeline. Current Protocols
in Bioinformatics, 43, 11.10.1–11.10.33. https://doi.org/10.1002/0471250953.bi1110s43
Wang, K., Li, M., & Hakonarson, H. (2010). ANNOVAR: Functional annotation of genetic variants from high-
throughput sequencing data. Nucleic Acids Research, 38(16), e164. https://doi.org/10.1093/nar/gkq603
Zhang, Z., et al. (2019). dbNSFP v4: A comprehensive database of functional predictions and annotations
for human nonsynonymous and splice-site SNVs. Human Mutation, 40(9), 1050–1057. https://doi.
org/10.1002/humu.23797
DNA-Protein Interactions
7
and Autoimmune Diseases
7.1 OVERVIEW OF DNA-PROTEIN INTERACTIONS
DNA-protein interactions are essential for regulating gene expression, shaping chromatin structure, and supporting vital cellular processes such as replication, repair, and recombination. These
interactions occur when specic proteins bind to precise DNA sequences using conserved structural
motifs, such as helix-turn-helix, zinc ngers, leucine zippers, or homeodomains (Figure 7.1). These
motifs enable proteins to recognize particular base pair sequences within the DNA’s major or minor
grooves by forming hydrogen bonds and other molecular contacts. The specicity of these interactions comes from the precise t between the amino acids in the protein and the DNA sequence.
The organization of chromatin further inuences DNA-protein interactions. In loosely packed
euchromatin, DNA is more accessible to transcription factors (TFs), whereas in tightly packed heterochromatin, DNA becomes less accessible. Enzymes known as chromatin remodelers and histonemodifying enzymes regulate this accessibility by modifying nucleosome positioning and altering
histone tail structures. This regulation allows proteins to access their DNA targets in response to
developmental cues, immune activation, or environmental stimuli.
In autoimmune diseases, disruptions in DNA-protein interactions are common and often contribute to pathological gene expression. Abnormal TF binding or alterations in chromatin structure
can result in the inappropriate activation or repression of genes involved in immune regulation.
For example, aberrant TF activity may lead to overexpression of inammatory cytokines or the
suppression of genes that enforce immune tolerance. These molecular disruptions set the stage
for chronic inammation and immune-mediated tissue damage, hallmarks of autoimmune pathophysiology. Understanding the molecular principles of DNA-protein interactions is thus critical
for deciphering immune dysregulation and developing targeted therapies (Luger et al., 1997;
Ptashne, 2005).
7.2 TRANSCRIPTION FACTORS AND GENE REGULATION IN AUTOIMMUNITY
TFs are regulatory proteins that control the expression of genes by binding to specic DNA
sequences, typically located within promoter regions (near the transcription start site (TSS)) or
distant enhancer elements. These DNA sequences often contain conserved or palindromic motifs,
short nucleotide patterns that are recognized with high specicity by TFs. This recognition is mediated by structural domains within the protein, such as helix-turn-helix, zinc nger, leucine zipper,
or homeodomain motifs, which allow the TF to dock into the major or minor grooves of the DNA
double helix and establish stable, sequence-specic interactions.
Once bound to their target sites, TFs exert their regulatory inuence by recruiting a variety
of cofactors. These may include co-activators, such as histone acetyltransferases (HATs), which
loosen chromatin structure to promote transcription, or co-repressors, such as histone deacetylases
(HDACs), which condense chromatin and suppress gene activity. TFs also facilitate or hinder the
recruitment of the general transcription machinery, including RNA polymerase II and associated
initiation factors, thus modulating the initiation of transcription.
In essence, TFs act as molecular switches that integrate signals from the cellular environment and
translate them into specic gene expression programs. Their combinatorial binding and dynamic
interactions enable the ne-tuning of gene expression across cell types, developmental stages, and
223 DO I: 10 .1201/97810 0 36 85432-7
Соседние файлы в папке Библиотека им академика М.И. Перельмана