-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathadvanced.qmd
220 lines (189 loc) · 13.9 KB
/
advanced.qmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
---
title: "Advanced homology modeling"
date: "August 21, 2023"
date-modified: "`r Sys.Date()`"
format:
html:
page-layout: full
toc: true
toc-location: right
toc-depth: 3
number-sections: true
number-depth: 1
link-external-icon: true
link-external-newwindow: true
bibliography: references.bib
editor:
markdown:
wrap: 80
---
```{r echo=FALSE, output=FALSE}
library(webexercises)
```
# From homology modeling to threading
Although we do not intend to describe in detail the evolution of modeling
methods, I briefly outline below the origin and transformation of advanced
protocols that outperform the classical single-template homology modeling during
the last three decades. This step-wise evolution of modeling methods is the
origin of the revolution of Alphafold and related protocols, which we will
discuss in the next [section](ai.html).
## Threading or Fold-recognition methods {#sec-threading}
As mentioned earlier, the introduction of HMM-based profiles during the first
decade of this century led to a great improvement in template detection and
protein modeling in the twilight zone, i.e., proteins with only distant homologs
(\<25-30% identity) in databases. In order to exploit the power of HMM searches,
those methods naturally evolved into iterative [threading]{.underline} methods,
based on multitemplate model construction, implemented in
[I-TASSER](https://zhanggroup.org/I-TASSER/) [@roy2010],
[Phyre2](http://www.sbg.bio.ic.ac.uk/phyre2/) [@kelley2015], and
[RosettaCM](https://new.rosettacommons.org/demos/latest/tutorials/rosetta_cm/rosetta_cm_tutorial)
[@song2013], among others. These methods are usually referred to as
**Threading** or **Fold-recognition** methods. Note that the classification of
modeling methods is often blurry. The current version of SwissModel and the use
of HHPred+Modeller already rely on HMM profiles for template identification and
alignment; being thus strictly also fold-recognition methods.
Both terms can be often used interchangeably, although some authors see
**Fold-Recognition** as any technique that uses structural information in
addition to sequence information to identify remote homologies, while
**Threading** would refer to a more complex process of modeling including remote
homologies and also the modeling of pairwise amino acid interactions in the
structure. Therefore, HHPRED is a fold-recognition method and its use along with
Modeller, could be indeed considered threading.
{#fig-frost .figure}
The Iterative Threading ASSembly Refinement
([I-TASSER](http://zhanglab.ccmb.med.umich.edu/I-TASSER)) from [Yang Zhang
lab](https://zhanggroup.org/) is one of the most widely used threading methods
and servers. This method was was ranked as the No 1 server for protein structure
prediction in the community-wide [CASP7](https://zhanggroup.org/casp7/21.html),
[CASP8](https://predictioncenter.org/casp8/groups_analysis.cgi?target_type=0&gr_type=server),
[CASP9](https://predictioncenter.org/casp9/CD/data/html/groups.2.html),
[CASP10](http://predictioncenter.org/casp10/groups_analysis.cgi?type=server),
[CASP11](http://www.predictioncenter.org/casp11/zscores_final.cgi?gr_type=server_only),
[CASP12](http://www.predictioncenter.org/casp12/zscores_final.cgi?&gr_type=server_only),
[CASP13](http://www.predictioncenter.org/casp13/zscores_final.cgi?model_type=best&gr_type=server_only),
and
[CASP14](http://www.predictioncenter.org/casp14/zscores_final.cgi?gr_type=server_only)
experiments. I-TASSER first generates three-dimensional (3D) atomic models from
multiple threading alignments and iterative structural assembly simulations that
are iteratively selected and improved. The quality of the template alignments
(and therefore the difficulty of modeling the targets) is judged based on the
statistical significance of the best threading alignment, i.e., the *Z*-score,
which is defined as the energy score in standard deviation units relative to the
statistical mean of all alignments.
{#fig-tasser .figure}
First, I-TASSER uses Psi-BLAST against curated databases to select sequence
homologs and generate a sequence profile. That profile is used to predict the
secondary structure and generate multiple fragmented models using several
programs. The top template hits from each threading program are then selected
for the following steps. In the second stage, continuous fragments in threading
alignments are excised from the template structures and are used to assemble
structural conformations of the sections that aligned well, with the unaligned
regions (mainly loops/tails) built by *ab initio* modeling. The fragment
assembly is performed using a modified replica-exchange Monte Carlo random
simulation technique, which implements several replica simulations in parallel
using different conditions that are periodically exchanged. Those simulations
consider multiple parameters, including model statistics (stereochemical
outliers, H-bond, hydrophobicity...), spatial restraints and amino acid pairwise
contact predictions ([see below](#maps)). In each step, output models are
clustered to select the representative ones for the next stage. A final
refinement step includes rotamers modeling and filtering out steric clashes.
One interesting thing about I-TASSER is that it is integrated within a server
with many other applications, including some of the tools that I-TASSER uses and
other advanced methods based on I-TASSER, like I-TASSER-MTD for large,
multidomain proteins or C-I-TASSER that implements a deep learning step, similar
to Alphafold2 (see [next section](ai.html)).
{#fig-rosettacm .figure
width="664"}
**RosettaCM** is an advanced homology modeling or threading algorithm by the
[Baker lab](https://www.bakerlab.org/), implemented in
[Rosetta](https://www.rosettacommons.org/software) software and the
[Robetta](https://robetta.bakerlab.org/) webserver. RossetaCM provides accurate
models by breaking up the sequence into fragments that are aligned to a set of
selected templates, generating accurate models by a threading processes that
uses different fragments from each of the templates. Additionally it uses minor
*ab initio* folding to fill the residues that could not be assigned during the
threading. Then, the model is closed by iterative optimization steps that
include Monte Carlo sampling. Finally, an *all-atom* refinement towards a
minimum of free energy [@song2013].
::: callout-important
### Puzzling nomenclature: comparative, homology or *ab initio* modeling?
*De novo* or *ab initio* modeling used to mean modeling a protein
[without]{.underline} using a template. However, this strict definition is
blurred in the 2000s (decade) by advanced methods that use fragments. Threading
protocols such as *RosettaCM* and *I-Tasser*, among others, use fragments that
may or may not come from homologous protein structures or not. Therefore, they
cannot be classified as *homology modeling,* but they are sometimes referred to
as *comparative* or hybrid methods.
:::
## Scoring functions in threading and deep-learning protein modeling {#scores}
In protein modeling, various scoring functions are used to evaluate the
similarity of protein structures. As you know, the Root-Mean-Square Deviation
(**RMSD**) measures three-dimensional similarity by calculating the RMSD of the
Cα atomic coordinates after structural alignment. However, it is sensitive to
outliers and may overlook good models. **TM-Score** is a normalized alternative
to RMSD, ranging from 0 to 1, which considers the length of the protein and is
less influenced by outliers.
In CASP, the score of the models is based on the Global Distance Test (**GDT**),
often expressed as a percentage between 0 and 100, which measures the number of
residues within a set distance cutoff. Specifically, the **GDT-TS** calculates
the average GDT for 1, 2, 4, and 8 Å cutoffs. Similar to RMSD, the GDT score is
length-dependent, as its average score for random structure pairs follows a
power-law dependence on protein size. To address this, the [**GDT-TS
Z-score**](https://proteopedia.org/wiki/index.php/Calculating_GDT_TS), used in
RosettaCM, indicates data quality and dispersion based on mean and standard
deviation values. This use of the Z-score or standard scores is common in
mathematics, reflecting how many standard deviations a raw score is from the
mean.
Finally, the
[**plDDT**](https://www.ebi.ac.uk/training/online/courses/alphafold/inputs-and-outputs/evaluating-alphafolds-predicted-structures-using-confidence-scores/plddt-understanding-local-confidence/),
or per-residue estimate **lDDT** [@mariani2013] used in AlphaFold and related
methods, provides a per-residue normalized score of Cα-atomic superposition-free
distance, with values ranging from 0 to 100. This scoring can refer to either a
single structure or an ensemble, offering detailed insights into protein
modeling accuracy. Additionally, if a protein region is naturally highly
flexible or intrinsically disordered, in which case it does not have any
well-defined structure, will also have a lower lDDT [@wilson2022].
# From contact maps to pairwise high-res feature maps {#maps}
A protein contact map illustrates the interactions between all possible pairs of
amino acid residues in a protein's three-dimensional structure. This is
displayed as a binary matrix with n rows and columns, where n represents the
number of residues in the sequence. In this matrix, the element at position *ij*
is marked as 1 if residues *i* and *j* are in contact within the structure.
Contact is typically defined as residues being closer than a certain distance
threshold, which is 9 Å in the examples shown in @fig-contact. The patterns in
these maps highlight the differences between motifs and reflect the stretches of
secondary structure.
{#fig-contact
.figure}
Accurate information on residue-residue contacts is sufficient to determine a protein's fold [@olmea1997]. However, using these maps in protein modeling is challenging, as predicting these contacts is not straightforward. The advent of direct-coupling analysis (**DCA**), which extracts residue coevolution from multiple sequence alignments (MSAs) as shown in @fig-coevol, has improved contact map predictions. This has facilitated their use in protein folding with methods such as PSICOV [@jones2012] and Gremlin [@kamisetty2013]. Nevertheless, for proteins with few sequence homologs, the predicted contacts are often low in quality, making accurate contact-assisted protein modeling difficult.
{#fig-coevol .figure}
### Implementation of several layers of information processed by neural network and deep learning methods {#sec-NN .section}
Deep learning is a sub-field of machine learning based on artificial neural networks (NNs). Neural networks were initially introduced in the late 1940s and 1950s but gained prominence again in the 2000s with the rise of computational capacities and the use of [GPUs](https://en.wikipedia.org/wiki/Graphics_processing_unit). Essentially, an NN uses multiple interconnected layers to transform various inputs, such as MSAs and high-resolution contact maps, into complex features that can then predict intricate outputs like a 3D protein structure. NNs aim to simulate the behavior of the human brain, processing large amounts of data and learning from it. Deep learning utilizes multiple-layer NNs to optimize and refine accuracy.
{#fig-families
.figure}
The next complexity level in contact maps involves applying them to distantly related proteins by comparing sets of DCA from different protein families, sometimes referred to as joint evolutionary coupling analysis (@fig-families). This method requires processing massive amounts of information, which increases computational demands. Hence, the use of trained neural networks and advanced deep-learning methods has significantly enhanced protein modeling capabilities.
In this context, the introduction of supervised machine learning methods that predict contacts has outperformed DCA methods by employing multilayer neural networks [@jones2015; @ma2015; @wang2017a; @yang2020]. These methods incorporate high-resolution contact maps (@fig-highres), containing enriched information that includes not only contacts but also distances and angles, represented in a heatmap-like probability scale.
{#fig-highres
.figure}