ProteinWeaver: A Divide-and-Assembly Approach for Protein Backbone Design

## Abstract

Abstract Nature creates diverse proteins through a ‘divide and assembly’ strategy. Inspired by this idea, we introduce ProteinWeaver, a two-stage framework for protein backbone design. Our method first generates individual protein domains and then employs an SE(3) diffusion model to flexibly assemble these domains. A key challenge lies in the assembling step, given the complex and rugged nature of the inter-domain interaction landscape. To address this challenge, we employ preference alignment to discern complex relationships between structure and interaction landscapes through comparative analysis of generated samples. Comprehensive experiments demonstrate that ProteinWeaver: (1) generates high-quality, novel protein backbones through versatile domain assembly; (2) outperforms RFdiffusion, the current state-of-the-art in backbone design, by 13% and 39% for long-chain proteins; (3) shows the potential for cooperative function design through illustrative case studies. To sum up, by introducing a ‘divide-and-assembly’ paradigm, ProteinWeaver advances protein engineering and opens new avenues for functional protein design.

## 1 Introduction

Nature employs a sophisticated ‘divide and assemble’ strategy to create large and intricate protein structures that meet diverse biological functional needs (Fig. 1A) (Pawson & Nash, ; Huddy et al., ; P Bagowski et al., ). This process primarily involves the recombination of existing structural blocks, particularly protein domains, which serve as the fundamental, recurring units in protein structures. Remarkably, a limited number of protein domains (approximately 500 as classified in CATH) suffice to create more than hundreds of thousands of structures satisfying a wide array of functions (Orengo et al., ). This strategy enables the creation of multi-domain protein backbones, facilitating the emergence of cooperative functions.

Figure: Figure 1: Overview of ProteinWeaver. (A) An illustration demonstrating the ‘divide-and-assembly’ approach to native protein evolution, which enhances cooperative function design. The pictures are adapted from this study (Aziz & Caetano-Anollés, ). (B) ProteinWeaver emulates natural strategies to create protein backbones. (C) ProteinWeaver is a backbone diffusion model. (D) The inter-domain structure-interaction landscape is complex and rugged, where minor structural modifications can lead to significant changes in interactions. Preference alignment technique aids in navigating this landscape effectively. (E) Existing methods struggle with long-chain backbone design, whereas ProteinWeaver demonstrates a considerable advantage. (F) A radar chart illustrates ProteinWeaver’s overall performance in long-sequence backbone design. Inter-domain quality is evaluated using interface scTM metrics.
Refer to caption: x1.png

Recent advances in protein backbone design have enabled the generation of novel and diverse structures with high designability (Watson et al., ; Ingraham et al., ; Yim et al., ; ; Bose et al., ; Lin & AlQuraishi, ; Lee et al., ; Wu et al., ). However, our analysis reveals a significant limitation: designability decreases markedly as the backbone length increases (Fig. 1E). This limitation may stems from inadequate inter-domain interaction, evidenced by a dramatic decrease in domain numbers and interface scTM compared to native proteins (Fig.9 and Fig.1F). These findings highlight the need for an approach to address the intricacies of multi-domain organization in backbone design, particularly for larger protein backbones.

In this study, inspired by nature’s strategies, we present ProteinWeaver (Fig.1B). Our method addresses the limitations of current approaches by breaking down the complex problem of backbone design into manageable components, framing it as a divide and assembly problem. ProteinWeaver operates in two stages (Fig. 1B): (1) Domain generation: We first divide the long sequence into multiple domains, focusing on generating these local structures independently, allowing for stable and accurate generation of individual domains; (2) Flexibly assembly: we employ a $\mathrm{SE(3)}$ diffusion model to learn the flexible assembly between these domains (Fig. 1C). This stage aims to capture the crucial inter-domain interactions. In short, this two-stage approach represents a brand-new paradigm for de novo backbone design.

The second assembly stage of our approach presents a significant challenge: designing optimal inter-domain interactions through precise weaving of independently generated protein domains. This process requires the model to navigate a complex landscape of potential structural arrangements and their corresponding interactions at a fine-grained level (Kuhlman & Bradley, ; Maguire et al., ). Two primary factors pose difficulties: (1) The scarcity of domain interaction data, which limits the model’s
capacity to capture the fine-grained structure-interaction landscape. (2) The absence of an efficient method to explore the relationship between structure and interaction energy, as folding methods such as Alphafold2 are computationally intensive and time-consuming for model optimization purpose (Jumper et al., ).

To address these challenges, we define domain assembly as a structure-interaction landscape optimization problem and implement preference alignment. Our approach consists of two key steps. We first conducted extensive sampling to generate diverse multi-domain structures and quantitatively evaluate their interaction quality using scTM metrics. This process captures the complex distribution of the structure-interaction energy landscape in a fine-grained manner (Fig. 1D). Then, we implemented preference alignment. Rather than learning mappings to predefined labels in conventional supervised fine-tuning (SFT), preference alignment enables our structure diffusion model to optimize through pairwise comparative analysis of the sampled structures, allowing the model to effectively navigate the intricate relationship between structure and interaction energy landscapes.

Our primary contributions can be summarized as follows:

- (1)
We propose the first ‘divide-and-assembly’ two-stage generation framework for protein backbone design. ProteinWeaver enables flexible assembly of general protein domains, allowing for the creation of sophisticated structures.
- (2)
We adopt the preference alignment technique to effectively navigate the domain interaction landscape and generate interaction-reasonable backbones in our diffusion model, which may provide a general approach benefiting backbone design.
- (3)
We present an extensive experimental evaluation of ProteinWeaver by comparing its performance with the state-of-the-art methods including RFdiffusion (Watson et al., ), Chroma (Ingraham et al., ), FrameDiff (Yim et al., ), and FrameFlow (Yim et al., ). ProteinWeaver significantly outperforms RFdiffusion by 13% to 39% in the quality of long-chain backbones (Fig. 1E) and exhibits comprehensive advantages across various metrics (Fig. 1F).
- (4)
We present ProteinWeaver’s potential applications for cooperative function design through targeted domain assembly, as illustrated by case studies in substrate-directed enzyme design and bispecific antibody engineering.

## 2 ProteinWeaver

In this section, we introduce the ProteinWeaver. The overall generation framework is introduced in Sec.2.1. Details for training and sampling are introduced in Sec.2.2 and Sec.2.3.

### 2.1 Divide and assembly diffusion framework

##### Protein backbone representation.

Following AlphaFold2 (Varadi et al., ), the structure of protein backbone is parameterized as a collection of rigid frames. For a protein backbone of length $L$, these frames are denoted by $\mathbf{T}=[T_{1},T_{2},...,T_{L}]\in\mathrm{SE(3)}^{L}$. Each frame $T_{i}=(r_{i},x_{i})$ where $r_{i}\in\mathrm{SO(3)}$ and $x_{i}\in\mathbb{R}^{3}$ maps a rigid transformation from fixed, idealized coordinates $\text{N}^{*},\text{C}_{\alpha}^{*},\text{C}^{*},\text{O}^{*}\in\mathbb{R}^{3}$, with $\text{C}_{\alpha}^{*}=(0,0,0)$. Thus, for each residue $i\in[1,2,...,L]$, $\mathbf{S}_{i}=[\text{N},\text{C}_{\alpha},\text{C},\text{O}]^{i}=T_{i}\circ[
\text{N}^{*},\text{C}_{\alpha}^{*},\text{C}^{*},\text{O}^{*}]\in\mathbb{R}^{4
\times{3}}$. To construct the backbone oxygen O, we use an additional torsion angle $\psi$ by rotating $\text{O}^{*}$ around the bond between $\text{C}_{\alpha}$ and C. Finally, the complete 3D structure coordinates with all heavy atoms of a protein is denoted as $\mathbf{S}\in\mathbb{R}^{L\times{4}\times{3}}$.

Figure: Figure 2: ProteinWeaver employs a two-staged ‘divide-and-Assembly’ framework, first generating individual protein domains and then using an SE(3) diffusion model to flexibly assemble these domains. $\bar{\mathbf{S}}$ represents isolated domains undergoing internal structural modifications for assembly into integrated backbones.
Refer to caption: x2.png

##### Overall architecture.

As shown in Fig.2, we can decouple the generation process of backbones into two stages: (1) divided domain generation and (2) domain assembly generation. This decoupling strategy enables us to break down the modeling of complex backbone structures into two manageable steps: generation of individual domains and assembly of these domains, which significantly simplifies the overall modeling process for complex protein structures.

It should be noted that the domain structure $\bar{\mathbf{S}}$ generated in stage 1 will change when assembled into the final structure $\mathbf{S}$. In other words, we are considering the flexible assembling of domains.

##### Divided domain generation.

Given the target protein backbone’s length $L$, the structure can be divided into domains $D=\{D_{1},D_{2},...,D_{m}\}\in{\text{partition}([1,2,...L],m)}$ where $\text{partition}(\cdot,m)$ is the function that returns all sequence partition(^1^11a ‘sequence partition’ refers to the process of dividing a sequence into several continues sub-sequences, such as $\text{partition}([1,2,3,4],2)=\{[[1,2,3],[4]],[[1,2],[3,4]],[[1],[2,3,4]]\}$) dividing the input sequence into $m$ parts, such that $D_{i}\cap{D_{j}}=\emptyset$ and $\bigcup_{i=1}^{m}{D_{i}}=\{1,2,...,L\}$. In practice, we can artificially construct $\{D_{1},D_{2},...,D_{m}\}$ where the length of each domain $D_{i}$ is $L_{i}$. Given the high designability of existing backbone generation methods for short sequences (Watson et al., ; Ingraham et al., ; Yim et al., ; ; Bose et al., ; Lin & AlQuraishi, ; Lee et al., ; Wu et al., ), we directly apply these established models to sample and generate individual domains. Given the domain length $L_{i}$, $f_{\theta}:\mathbb{N}^{+}\rightarrow\mathbb{R}^{L_{i}\times 4\times{3}}$ generates individual domains $\bar{\mathbf{S}}_{D_{i}}$. Here, $\theta$ represents domain generator module, $\bar{\mathbf{S}}\in\mathbb{R}^{L\times{4}\times{3}}$is domain residue coordinates before assembly and $\bar{\mathbf{S}}_{D_{i}}$ is the element corresponding to the index of $D_{i}$. Various backbone generation methods such as FrameDiff, Chroma, and RFdiffusion can be applied here to generate individual domains.

##### Domain assembly generation.

We focus on designing the assembled structure given independently generated domains $\{\bar{\mathbf{S}}_{D_{1}},\bar{\mathbf{S}}_{D_{2}},...,\bar{\mathbf{S}}_{D_{m
}}\}$ (Fig.2). We assume the structure of individual domains can undergo overall spatial rotation and translation, along with inner-domain structural perturbations, to generate variable $\mathbf{S}$. To complete this flexible assembling process, we constructed a diffusion model conditioned on the spliced distance map of generated domains.

We initialize the process by extracting $C_{\alpha}$ distance maps $\{\bar{\mathbf{M}}_{D_{1}},\bar{\mathbf{M}}_{D_{2}},...,\bar{\mathbf{M}}_{D_{m
}}\}$ from domain backbones $\{\bar{\mathbf{S}}_{D_{1}},\bar{\mathbf{S}}_{D_{2}},...,\bar{\mathbf{S}}_{D_{m
}}\}$ derived from stage 1 generation. Then, we obtain the spliced distance map $\bar{\mathbf{M}}$ by diagonal concatenating distance maps $\{\bar{\mathbf{M}}_{D_{1}},\bar{\mathbf{M}}_{D_{2}},...,\bar{\mathbf{M}}_{D_{m
}}\}$ using Eq. (1) ($\text{SDM}(\cdot)$(^2^22In this paper, $\text{SDM}(\bar{\mathbf{M}}_{D_{1}},\bar{\mathbf{M}}_{D_{2}},...,\bar{\mathbf{ M}}_{D_{m}})$, $\text{SDM}(\bar{\mathbf{S}}_{D_{1}},\bar{\mathbf{S}}_{D_{2}},...,\bar{\mathbf{ S}}_{D_{m}})$, $\text{SDM}(\mathbf{S})$ all represent the diagonal concatenation of the distance maps corresponding to the refolded domains of a given structure $\mathbf{S}$.) represents the splicing distance map), and setting non-diagonal portions (representing inter-domain interactions) to -1 as shown in Fig.2.

$$ $\bar{\mathbf{M}}=\text{SDM}(\bar{\mathbf{M}}_{D_{1}},\bar{\mathbf{M}}_{D_{2}}, ...,\bar{\mathbf{M}}_{D_{m}})=\begin{bmatrix}\bar{\mathbf{M}}_{D_{1}}&\mathbf{ -1}&\cdots&\mathbf{-1}\\ \mathbf{-1}&\bar{\mathbf{M}}_{D_{2}}&\ddots&\vdots\\ \vdots&\ddots&\ddots&\mathbf{-1}\\ \mathbf{-1}&\cdots&\mathbf{-1}&\bar{\mathbf{M}}_{D_{m}}\end{bmatrix}.$ (1) $$

This spliced distance map $\bar{\mathbf{M}}$ initializes the edge representation, providing condition for the diffusion model, as shown in Appendix A.2.1.
To enhance the spatial flexibility of domain assembly, we insert a 15-residue linker between adjacent domains and set its interaction with other resions to $\mathbf{-1}$. The model is tasked with learning the deformations generated by each domain in $\{\bar{\mathbf{S}}_{{D}_{1}},\bar{\mathbf{S}}_{{D}_{2}},...,\bar{\mathbf{S}}_{
{D}_{m}}\}$ during the combination process as well as the patterns of the ultimate interactions.

To assemble generated domains, we utilize FrameDiff  (Yim et al., ), the $\mathrm{SE(3)}$ diffusion model to pretrain the domain assembly model. As illustrated in the Appendix A.2.1, the assembly module contains a series of folding blocks, where each folding block processes node representation, edge representation and structural frames.

Given the spliced distance map $\bar{\mathbf{M}}$, we iteratively sample the assembled backbone structure through

$$ $(\hat{\mathbf{T}}^{(0)},\hat{\psi})=g_{\phi}(\mathbf{T}^{(t)},t,\bar{\mathbf{M }}),$ (2) $$

where $g_{\phi}:\mathrm{SE(3)}^{L}\times{[0,1]}\times{\mathbb{R}^{L\times{L}}}
\rightarrow\mathrm{SE(3)}^{L}\times{\mathbb{R}}$, $t$ is the diffusion step, $\mathbf{T}^{(t)}$ is the iteratively sampled rigid bodies, $\hat{\mathbf{T}}^{(0)}$ is the predicted assembled backbone structure’s rigid bodies and $\hat{\psi}$ is the predicted torsion angle. When the diffusion process ends at time $t_{0}$, we can obtain the backbone coordinates $\mathbf{S}$ based on $[\text{N}^{*},\text{C}_{\alpha}^{*},\text{C}^{*},\text{O}^{*}]$ by applying $\hat{\mathbf{T}}^{(0)}$ and rotation angle $\hat{\psi}$.

### 2.2 Training

In this section, we provide the details of ProteinWeaver training, including datasets, pretraining, and preference alignments. More details can be found in Appendix A.2.1.

##### Dataset.

To train ProteinWeaver, we constructed a set composed of $(\bar{\mathbf{M}},\mathbf{S})$ pairs. The structure of protein backbone $\mathbf{S}$ in this set is sourced from the Protein Data Bank (PDB). Following Yim et al. (), we filter for single-chain monomers between length 60 and 512 with resolution $<5\text{\r{A}}$ downloaded from PDB (Berman et al., ) on March 2, 2024. We further filtered the data with more than $50\%$ loops and left with 22728 proteins. Multi-domain PDB structures were further filtered, resulting 5835 PDB structures for pretraining. For each PDB, we identify the domain number $m$ and domain index $\{D_{1},D_{2},...,D_{m}\}$ through Unidoc (Ribeiro et al., ). Finally, we convert them to $C_{\alpha}$ distance maps and use Eq. (1) to get $\bar{\mathbf{M}}$.

##### Pretraining.

In our pipeline, domain assembly generation involves the flexible assembling of domains into integrated backbones. The intra-domain structures are alternated during the assembly for optimal inter-domain interaction. To maintain consistency between the pretraining and inference stages, we refolded each domain $\{\mathbf{S}_{D_{1}},\mathbf{S}_{D_{2}},...,\mathbf{S}_{D_{m}}\}$ to $\{\bar{\mathbf{S}}_{D_{1}},\bar{\mathbf{S}}_{D_{2}},...,\bar{\mathbf{S}}_{D_{m
}}\}$ of multi-domain PDB using ESMFold (Lin et al., ), mimicing their unassembled states for training.

In the pretraining stage, we adopted the training loss from FrameDiff, comprising two main components: diffusion score-matching loss for translation and rotation, along with auxiliary losses related to the coordinate and pairwise distance loss on backbone atoms, as depicted in Eq. (3).

$$ $\mathcal{L}=\mathcal{L}_{\text{trans}}+0.5\cdot\mathcal{L}_{\text{rot}}+0.25 \cdot\mathcal{L}_{\text{atom}}^{t<0.25}+0.25\cdot\mathcal{L}_{\text{pairwise}} ^{t<0.25}.$ (3) $$

Here, $\mathcal{L}_{\text{trans}}$ computes the loss between predicted translations with reference translations, while $\mathcal{L}_{\text{rot}}$ calculates the loss of rotation scores. $\mathcal{L}_{\text{atom}}$ represents the atom coordinate loss and $\mathcal{L}_{\text{pairwise}}$ computes the pairwise distance loss between predicted and reference positions. Following FrameDiff (Yim et al., ), we apply auxiliary losses when $t\leq{0.25}$. More details can be found in Appendix A.2.2.

##### Preference alignment.

By utilizing Eq. (3) to train the model, ProteinWeaver has acquired knowledge of assembling patterns found in natural proteins. However, during the pretraining stage, Eq. (3) only enables the model to maximine the likelihood of the data set $p(\mathbf{S})$, whereas our target is to maximize the quality of the generated structure $\mathbf{S}$ measured by scTM score. Different assembling approaches can result in varying qualities of flexible assembling structures.

To enable the model to generate proteins with higher scTM scores based on pretraining, we employed Eq. (4) as the alignment objective. Here, $r(\mathbf{S},\mathbf{S}_{\text{ref}})$ serves as a reward function to provide feedback on the scTM score of $\mathbf{S}$, $\pi_{\text{ref}}$ is a copy of $\pi_{\phi}$ and remains frozen during alignment, $\beta$ is self-paced learning rate. By adjusting $\beta$, we can maximize $r(\mathbf{S},\mathbf{S}_{\text{ref}})$, i.e., the scTM score, while ensuring minimal difference between $\pi_{\phi}$ and $\pi_{\text{ref}}$. We use $\Omega$ to represent all protein backbone structures in the alignment stage.

$$ $\max\limits_{\pi_{\phi}}\mathbb{E}_{\mathbf{S}_{\text{ref}}\sim{\Omega},\bar{ \mathbf{M}}=\text{SDM}(\mathbf{S}_{\text{ref}}),\mathbf{S}\sim{\pi_{\phi}( \mathbf{S}|\bar{\mathbf{M}})}}[r(\mathbf{S},\mathbf{S}_{\text{ref}})]-\beta \mathbb{D}_{\text{KL}}[\pi_{\phi}(\mathbf{S}|\bar{\mathbf{M}})||\pi_{\text{ref }}(\mathbf{S}|\bar{\mathbf{M}})].$ (4) $$

In particular, we use SPPO for preference alignment(Wu et al., ). To apply this alignment, we need to build the preference dataset and construct the “winning” and “losing” pair. We used Unidoc to split the proteins in PDB into single domain structures, and used TMalign (Zhang & Skolnick, ) to deduplicate all domain structures, retaining 100 domain structures. Then, we transform these 100 domain structures into $C_{\alpha}$ distance maps. Using Eq. (1), we combined these 100 domain structure distance maps to construct 10,000 different spliced distance maps. For each spliced distance map, we use ProteinWeaver to generate 3 structures, and use scTM score to identify winner $\mathbf{S}_{w}$ and loser $\mathbf{S}_{l}$ to construct data pairs used for SPPO alignment. Finally, we constructed 10,000 data pairs for SPPO alignment.

$$ $\mathcal{L}_{\text{SPPO}}(\bar{\mathbf{M}},\mathbf{S}_{w},\mathbf{S}_{l};\pi_{ \phi},\pi_{\text{ref}},\beta):=\left(\beta\log\frac{\pi_{\phi}(\mathbf{S}_{w}| \bar{\mathbf{M}})}{\pi_{\text{ref}}(\mathbf{S}_{w}|\bar{\mathbf{M}})}-\frac{1} {2}\right)^{2}+\left(\beta\log\frac{\pi_{\phi}(\mathbf{S}_{l}|\bar{\mathbf{M}} )}{\pi_{\text{ref}}(\mathbf{S}_{l}|\bar{\mathbf{M}})}+\frac{1}{2}\right)^{2}.$ (5) $$

Figure: Algorithm 1 ProteinWeaver Model Inference

We determine the preference according to quality of assembled backbones using scTM metrics. Winner is defined as the data with higher backbone quality $\mathbf{S}_{w}$ (winner data), along with its corresponding lower quality data $\mathbf{S}_{l}$ (loser data), which are determined by scTM score. These pair data generated under the same conditions ($\bar{\mathbf{M}}$ in our setting). Our approach finalizes the fine-tuning process by maximizing the loss function $\mathcal{L}_{\text{SPPO}}(\bar{\mathbf{M}},\mathbf{S}_{w},\mathbf{S}_{l};\pi_{
\phi},\pi_{\text{ref}})$, enabling the model to produce a structure that closely resembles the winner data and significantly differs from the loser data within the constraints set by the distance map $\bar{\mathbf{M}}$.

### 2.3 Inference

The overall sampling process is summarized in Algorithm 1. We first sample domain division from $\text{partition}([1,2,...,L],m)$. For each domain, we use $f_{\theta}$ generates corresponding domain. Then, we convert them into $C_{\alpha}$ distance map and use $\text{SDM}(\cdot)$ to get spliced distance map. Finally, using $\mathrm{SE(3)}$ SDE introduced in Yim et al. (), we obtain the rigid frames $\mathbf{T}^{(t_{0})}$ and calculate final complete protein backbone $\mathbf{S}$.

## 3 Experiments

We evaluate ProteinWeaver against state-of-the-art protein backbone generation strategies, demonstrating its superiority in four key areas: (1) Domain assembly: ProteinWeaver generates high-quality domain-assembled backbones across diverse domain sources in Sec.3.2. (2) General backbone design: ProteinWeaver outperforms existing methods like RFdiffusion in creating novel, high-quality long-chain backbones in Sec.3.3. (3) Cooperative function design: ProteinWeaver generates function-cooperated backbones through targeted domain assembly, as evidenced by case studies in Sec.3.4. (4) Ablation study in Sec.3.5.

### 3.1 Experimental setups

##### Tasks.

We evaluate ProteinWeaver’s performance using two tasks: (1) Domain assembly: this is a new protein backbone design task, introduced in our study, lacking existing deep learning-based baselines. It serves both as an appropriate scenario to evaluate our approach and as an important protein engineering task previously studied using traditional method (Huddy et al., ). (2) Backbone design: This task focuses on the design of de novo proteins, a subject of significant interest in the global research community. When generating backbone, we use the best of 3 operation (bo3). More details are provided in Appendix A.6.

##### Baselines.

We compare ProteinWeaver with various representative protein backbone design baselines, including Chroma (Ingraham et al., ), RFdiffusion (Watson et al., ), and FrameFlow Yim et al. (). To verify the effectiveness of alignment, we also compare a supervised fine-tuning (SFT) based fine-tuning strategy.

##### Dataset.

We pretrained the diffusion model for domain assembly using 5,835 filtered multi-domain PDBs from the RCSB database (Berman et al., ). For the preference alignment, we performed pairwise combinations of 100 single-domain structures, generating 10,000 pairs to build winner and loser datasets for alignment. Detailed methodology is provided in Appendix A.1.1 and A.1.2.

##### Metrics.

We evaluate generation conformations as to their overall backbone quality, interface quality, novelty, and diversity. We also provide interface scTM and scRMSD metrics for domain assembly quality evaluation. More details are provided in Appendix A.5.

### 3.2 Evaluation of Protein Domain Assembly

##### ProteinWeaver demonstrates strong capability in assembling native domains.

We assessed ProteinWeaver’s domain assembly capacity using split domains from native PDBs. As shown in Fig.3A and Tab.1, ProteinWeaver effectively assembles PDB domains (red bars) to form high-quality integrated backbones (mean scTM of 0.88 and mean scRMSD of 2.15). The inter-domain scTM evaluation displays high mean scTM scores of 0.74, suggesting highly consistent domain interfaces between the designed backbone and the ESMfold-refolded structure. Notably, the backbone structures of domains undergo significant alterations after the assembly process, highlighting ProteinWeaver’s ability to integrate domains flexibly (Fig.10). To further challenge ProteinWeaver, we used randomly sampled domains from CATH (Orengo et al., ) with uncertain assemblability. This resulted in decreased performance (pink bars in Fig. 3A), as expected given the increased difficulty of the task. Despite the performance decrease, we include these results as a benchmark for this challenging task to benefit future studies.

Figure: Figure 3: ProteinWeaver enables high-quality backbone design by assembling domains from diverse sources. (A) Backbone and interface quality estimation of native domain assembly. (B) Backbone and interface quality estimation of synthesized domain assembly. (C) Case studies showing the diverse assembled domains. The designed backbone and the refolded backbones (grey) are aligned with assembled backbones (green and blue color coding to different domains). The evaluation was conducted without employing the best-of-three filter.
Refer to caption: x3.png

##### ProteinWeaver exhibits strong generalizability in assembling synthesized domains.

To evaluate ProteinWeaver’s robustness in assembling distinct domains, we conducted tests using domains synthesized by RFdiffusion. As shown in Fig.3B and Tab.2, ProteinWeaver effectively assembled these synthesized domains into high-quality backbones (green bar), achieving median scTM scores of 0.92, comparable to results with native split PDB domains. We also observed satisfactory inter-domain interface quality, with an mean interface scTM of 0.80. We further assessed ProteinWeaver’s assembly capacity using domains generated by various backbone design approaches. While domains from other methods could also be assembled, results showed decreased performance for Chroma (yellow), FrameFlow (purple), and FrameDiff (red). This observation may suggest the quality of individual domains impacts the overall quality of assembled backbones. Case studies presented in Fig.3C demonstrate ProteinWeaver’s generalizability in assembling domains from different sources, with diverse topologies and secondary structures, into high-quality integrated backbones.

### 3.3 Evaluation of Protein Backbone design

##### ProteinWeaver significantly improves the designability of long-chain backbones.

ProteinWeaver facilitates protein backbone design through the assembly of synthesized domains. We evaluated the performance against state-of-the-art methods across protein lengths ranging from 100 to 800 residues (Fig.4 and Tab.2).
For proteins between 100 and 400 residues, all the methods are capable of generating high-quality backbones. However, when it comes to generating proteins with 500 to 800 amino acids, the quality of the baseline methods drops rapidly. In contrast, ProteinWeaver consistently maintains its design ability. Specifically, ProteinWeaver (red line) achieves mean scTM scores of 0.86 for 500-residue proteins (compared to RFdiffusion’s 0.76), 0.79 vs. 0.66 for 600-residue proteins, and 0.68 vs. 0.49 for 800-residue proteins. This represents approximately 13% and 39% performance improvements over RFdiffusion in long-chain backbone design for 500 and 800 residues, respectively. These results underscore the effectiveness of the ‘divide-and-assembly’ strategy for long-chain backbone design, demonstrating ProteinWeaver’s superior performance in designing extended protein structures.

Figure: Figure 4: ProteinWeaver shows strong capacity in designing novel and high-quality backbones with significant improvement, particularly in long-chain structures.
Refer to caption: x4.png

##### ProteinWeaver significantly enhances the novelty of backbone design.

As shown in Fig.4, ProteinWeaver consistently achieves better novelty compared to existing backbone design approaches for chain lengths ranging from 100 to 300 residues. The advancement may stem from ProteinWeaver’s ‘divide-and-assemble’ strategy, which enables the combination of diverse domains to create novel backbones. For longer chains (500 to 800), other backbone design methods show improved novelty alongside decreased design quality. In contrast, ProteinWeaver generates novel long-chain structures maintaining high quality, demonstrating its strength in designing long protein backbones.

### 3.4 Function-cooperated Backbone Design

##### ProteinWeaver supports targeted domain assembly, facilitating function-cooperated backbone design.

Figure: Figure 5: Case studies showing ProteinWeaver potentially enables cooperative function design through the assembly of assigned proteins.
Refer to caption: extracted/5983708/figs/figure3.png

Inspired by nature’s domain assembly strategy for optimizing and creating new functions (Pawson & Nash, ), we applied ProteinWeaver to assemble four protein types, focusing on three functional classes: (1) Nanobodies: simplified antibodies that defend against diseases (De Meyer et al., ); (2) Scaffold proteins: target-directed ”GPS” molecules (Burack & Shaw, ); and (3) Enzymes: proteins that catalyze chemical reactions (Kirk et al., ). As shown in Fig.5, ProteinWeaver efficiently assembles these proteins, generating stable interfaces in both self-assembly and cross-assembly configurations. The resulting backbones present potential function-cooperative designs worthy of further investigation. For instance, assembled nanobodies could simultaneously bind different antigens, potentially enhancing synergistic effects (Lewis et al., ), while scaffold-enzyme assemblies may improve enzyme target selectivity (Park et al., ) (Fig.5). These cases provide biologically significant proof-of-concept, demonstrating ProteinWeaver’s ability to create a vast space for functional optimization and design.

### 3.5 Ablation study

##### Training using refolded domains is crucial for ProteinWeaver to learn domain assembly.

We hypothesized that training using refolded domains, which mimics their isolated states, facilitates ProteinWeaver’s learning of structural interactions during domain assembly. To evaluate this, we compared ProteinWeaver trained on refolded domains (yellow bars) with a version trained on domains directly split from PDBs without refolding (green bars). As shown in Fig.6 and Tab.1, the model trained on directly split structures exhibited significantly impaired performance in domain assembly tasks. This phenomenon was consistently observed in both domain assembly and protein backbone design tasks (Fig.7). These results demonstrate the importance of using refolded domain structures in model training for effective domain assembly learning.

##### Preference alignment efficiently optimizes performance for domain assembly and backbone design.

To evaluate the effectiveness of preference alignment in optimizing domain assembly, we compared ProteinWeaver with alignment (red bar) to a version without alignment (yellow bar). As shown in Fig.6 and Tab.3, alignment significantly improved performance across backbones assembled using various domains, including split domains from PDB, designed domains, and CATH domains. Inter-domain scTM evaluation further confirmed these results, demonstrating preference alignment’s high efficiency in optimizing domain interaction quality. We extended this ablation study to general backbone design (Fig.7). ProteinWeaver with alignment (purple line) consistently outperformed the version without alignment (blue line) in generating assembled domains of higher quality. This suggests that alignment is effective in optimizing inter-domain interactions across different design tasks.

Figure: Figure 6: Ablation study on domain assembly. (A) The backbone quality and (B) Interface quality are evaluated. Distinct sourced-domains are tested. The evaluation was conducted without employing the best-of-three filter.
Refer to caption: x5.png

##### Preference alignment outperforms Supervised Fine-tuning in optimizing domain assembly.

We conducted ablation studies to compare the effectiveness of preference alignment with Supervised Fine-tuning (SFT), an alternative method for optimizing high-quality domain assembly. For SFT, we utilized the “winner” dataset from the preference alignment process to fine-tune the model. As shown in Fig.7, ProteinWeaver fine-tuned with preference alignment (red bar) significantly outperformed the version fine-tuned with SFT (purple bar). These results strongly suggest that preference alignment is more effective than SFT for optimizing domain assembly in this task.

Figure: Figure 7: Ablation study on backbone design. “bo3” is abbreviation for best of 3.
Refer to caption: x6.png

## 4 Related work

### 4.1 Diffusion modeling on protein backbone

Inspired by the considerable success of diffusion models across various fields (Ho et al., ; Song et al., ), researchers have applied this approach to protein structure and sequence design. Anand et al. pioneered this effort with a co-diffusion model for backbone, sequence, and sidechain generation using AlphaFold2’s Structure Module  (Anand & Achim, ) . Subsequent methods explored diffusion on inter-residue geometry  (Lee et al., ) and backbone dihedral angles  (Wu et al., ). Current protein structure diffusion models primarily focus on end-to-end structure generation in SE3 or R3 space  (Yim et al., ), with extensions to function motif scaffolding  (Trippe et al., ; Yim et al., ). Chroma achieved more general conditioning and improved efficiency through geometrically constrained harmonic constraints  (Ingraham et al., ), while RFdiffusion demonstrated state-of-the-art designability with experimental validation  (Watson et al., ). However, despite these advancements, the capacity of these state-of-the-art methods for long-chain backbone generation remains limited, highlighting an area for further research and development in the field of protein design.

## 5 Conclusions and discussions

##### Conclusions.

In this paper, we introduce ProteinWeaver, the first protein backbone design model based on a ‘divide-and-assembly’ framework. This approach enables the creation of novel, high-quality backbones through the flexible assembly of diverse domains. ProteinWeaver demonstrates superior performance in general backbone design, particularly excelling in the challenging task of designing long-chain backbones compared to existing state-of-the-art approaches. The assembly capability of ProteinWeaver not only advances current protein design methods but also lays the groundwork for cooperative function design, potentially opening new avenues for protein engineering.

##### Discussions.

Despite these advances, several limitations of our current model warrant further investigation. (1) Controllability: The current version of ProteinWeaver lacks control over specific structural features or functional properties of the generated proteins. (2) Side-chain Information: Our model focuses on backbone design and does not include detailed side-chain information, which is crucial for precise protein function prediction and design. (3) Robustness: While ProteinWeaver shows promising results, the robustness of the domain assembly, especially the randomly sampled CATH domain, requires further improvement. Addressing these limitations in future work could significantly enhance the applicability and reliability of ProteinWeaver for diverse protein design tasks. (4) Spatial flexibility in domain assembly: In this study, we design protein backbones by assembling domains in one single chain. While this goal is effective in our current study, it may limit the exploration of more diverse spatial arrangements. Future research could investigate variable linker lengths or even linker-free assembly methods, to potentially address more challenging problems, such as protein-protein docking.

While our framework demonstrates a new paradigm for protein backbone design, we acknowledge several technical aspects that warrant further investigation: (1) Recent advancements have revealed that flow matching-based protein backbone generation methods outperform diffusion-based approaches. An exciting avenue for future research lies in exploring whether replacing our current diffusion-based framework with a flow matching-based approach could yield further benefits; (2) Domain structure representation: Our current method explicitly represents local domain structures as distance maps. However, the efficacy of alternative pairwise representation methods remains an open question. Investigating various representation techniques could provide crucial insights into the most effective ways to capture and utilize structural information in protein design, potentially uncovering superior approaches. (3) Integration of design stages: Currently, our approach employs two separate steps for backbone design. A promising direction for future research is developing an end-to-end unified framework that efficiently integrates these steps. Future research could further refine and extend this framework by addressing these questions, potentially revolutionizing our ability to create functional protein backbones with unprecedented precision.

## Appendix A Experimental Setup

### A.1 Data Processing

#### A.1.1 Pretraining data

To train ProteinWeaver, specifically the assembly generator, a series of spliced distance maps $\bar{\mathbf{M}}$ and the corresponding structures $\mathbf{S}$ are required. In pretraining stage, our structures are sourced from the PDB dataset. Following Yim et al. (), we filter for single-chain monomers between length 60 and 512 with resolution $<5\text{\r{A}}$ downloaded from PDB (Berman et al., ) on March 2, 2024, resulting in 22,728 proteins.

For each protein $\mathbf{S}$, we used Unidoc to identify the domain number $m$ and domain indices $\{D_{1},D_{2},...,D_{m}\}$. For proteins where $m=1$, , we directly converted their structures into the corresponding $\text{C}_{\alpha}$ distance map $\bar{\mathbf{M}}$. If $m>1$, we initially segmented the PDB structure into domain structures $\{\mathbf{S}_{D_{1}},\mathbf{S}_{D_{2}},...\mathbf{S}_{D_{m}}\}$ based on the domain indices identified by Unidoc. Subsequently, we refolded each domain structure using ESMFold to construct the refolded domain structures $\{\bar{\mathbf{S}}_{D_{1}},\bar{\mathbf{S}}_{D_{2}},...\bar{\mathbf{S}}_{D_{m}}\}$. Refolding with ESMFold ensures the independence of domain structures, maintaining consistency between training and inference.

Finally, we converted the refolded domain structures $\{\bar{\mathbf{S}}_{D_{1}},\bar{\mathbf{S}}_{D_{2}},...\bar{\mathbf{S}}_{D_{m}}\}$ into their corresponding $\text{C}_{\alpha}$ distance map $\{\bar{\mathbf{M}}_{D_{1}},\bar{\mathbf{M}}_{D_{2}},...,\bar{\mathbf{M}}_{D_{m
}}\}$ and utilized Eq. (1) to transform them into spliced distance map $\bar{\mathbf{M}}$. Among these 22,728 proteins, Unidoc identified 5,835 multi-domain PDB structures.

#### A.1.2 Alignment data

In this paper, we utilized SPPO for preference alignment of the pretrained models. To construct the alignment dataset, a series of pair datas consisting of winner data $\mathbf{S}_{w}$ and loser data $\mathbf{S}_{l}$ needed to be obtained. To achieve this, the following steps were undertaken: (1) Construction of the distance map $\bar{\mathbf{M}}$. (2) Generation of multiple structural data using $\bar{\mathbf{M}}$ as a condition. (3) Selection of metrics to evaluate the quality of data, leading to the construction of winner data and loser data.

To construct the distance map $\bar{\mathbf{M}}$, similar to building the pretraining dataset, we segmented the proteins from the PDB into single-domain structures using Unidoc. Subsequently, we de-duplicated these single-domain structures using TMalign (with a threshold set at 0.3). Following this, we randomly selected 100 single domains and combined them randomly to create 10,000 domain combinations. Eq. (1) was then applied to derive the corresponding spliced distance map for each combination.

For each spliced distance map, ProteinWeaver was employed to generate three structures, with the scTM score utilized as the metric for distinguishing between winner and loser data. Ultimately, we established 10,000 pairs of pair datas for SPPO alignment.

### A.2 Model

#### A.2.1 Model architecture

ProteinWeaver iteratively updates the structural frames of proteins through a sequence of $L$ layers of folding blocks. A folding block is composed of three modules: an IPA module, a backbone update module, and a edge update module. Each layer of the folding block takes single representation, pair represetation and frames as input.

Following Yim et al. (), we add a skip connection and a $2$-layers transformer encoder to original IPA (Jumper et al., ). The IPA module takes the single and pair representations and frames as input. For edge update module, we use a linear layer operates on pair representation with a single representation-gated structural bias. For backbone update module, we use a MLP to predict translation and rotation updates for the frames of each residue, where the input to MLP is single represetation.

There are no weights shared among the $L$ folding blocks. The sequence representation is initialized using the diffusion timestep and the edge representation is initialized using spliced distance map.

#### A.2.2 SE(3) diffusion

##### Protein Backbone Diffusion model on SE(3) .

In protein backbone design, a common modeling approach involves the utilization of $\mathrm{SE(3)}$ diffusion as proposed in Yim et al. (). In this $\mathrm{SE(3)}$ diffusion, each amino acid is modeled as a frame, with rotation and translation variables diffused separately to complete the modeling process. The forward diffusion formula for this SE(3) diffusion is as follows:

$$ $d\mathbf{T}^{(t)}=[\mathbf{0},-\frac{1}{2}\mathbf{X}^{(t)}]dt+[d\mathbf{B}_{ \mathrm{SO(3)}}^{(t)},d\mathbf{B}_{\mathbb{R}^{3}}^{(t)}].$ (6) $$

Here, $\mathbf{B}$ represents Brownian motion ($\mathbf{B}_{\text{SO(3)}}$ and $\mathbf{B}_{\mathbb{R}^{3}}$ represent Brownian motion on $\mathrm{SO(3)}$ and $\mathbb{R}^{3}$ respectively), $t\in{[0,1]}$. $t=1$ is initialized noise data and $t=0$ is final sampling data.

In Yim et al. (), the forward diffusion probability of the translation variable is defined as $p_{t|0}(x^{(t)}|x^{(0)})=\mathcal{N}(x^{(t)};e^{-t/2}x^{(0)},(1-e^{-t})Id_{3})$. Based on the forward diffusion probability formula, we can obtain the explicit score of the translation variable using Eq. (7).

$$ $\nabla\log{p_{t|0}(x^{(t)}|x^{(0)})}=(1-e^{-t})^{-1}(e^{-t/2}x^{(0)}-x^{(t)}).$ (7) $$

Correspondingly, the forward diffusion probability on $\mathrm{SO(3)}$ is defined as $p_{t|0}(r^{(t)}|r^{(0)})=f(\omega(r^{(0)^{T}}r^{(t)}),t)$, where $\omega(r)$ is the rotation angle in radians for any $r\in\mathrm{SO(3)}$. The probability estimation on $\mathrm{SO(3)}$ can be represented as

$$ $f_{\text{IGSO}3}(\omega,t)=\sum_{\ell\in{\mathbb{N}}}(2\ell+1)e^{-\ell(\ell+1) t/2}\frac{\sin{((\ell+1/2)\omega)}}{\sin(\omega/2)}.$ (8) $$

Based on Eq. (8), we can obtain the score of the rotation variable on $\mathrm{SO(3)}$ as follows:

$$ $\nabla\log{p_{t|0}(r^{(t)}|r^{(0)})}=\frac{r^{(t)}}{\omega(t)}\log(r^{(0,t)}) \frac{\partial_{\omega}f(\omega(t),t)}{f(\omega(t),t)}.$ (9) $$

By training based on Eq. (7) and Eq. (9), we can obtain denoising networks on $\mathrm{SO(3)}$ and $\mathbb{R}$, thereby completing the denoising process for $\mathrm{SE(3)}$. Specifically, we generate domains of varying lengths using models like Chroma, RFdiffusion, and FrameFlow. We filter for domains with scTM >0.8, then assemble them using ProteinWeaver.

### A.3 Training Details

#### A.3.1 Loss

Following Yim et al. (), we use DSM loss ($\mathcal{L}_{\text{trans}}$ and $\mathcal{L}_{\text{rot}}$) to learn the translation and rotation score to ensure that the model learns the correct SE(3) diffusion process.

##### Auxiliary losses.

We use two additional losses to learn atom distance and directly penalize atomic errors in the final time step of generation. For a generated protein backbone structure $\mathbf{S}\in\mathbb{R}^{L\times{}}$, we have a referece backbone structure $\hat{\mathbf{S}}$. Correspondingly, we can get the coordinates of all atoms $\mathbf{A}\in\mathbb{R}^{N_{\text{atom}}\times{3}}$ corresponding to the generated protein backbone structure and the coordinates of all atoms $\hat{\mathbf{A}}$ of the reference backbone structure. where $N_{\text{atom}}$ is the number of atoms of the generated structure. After that, by calculating the relative distance between atoms, we can get the predicted atomic relative distance matrix $\mathbf{M}_{\mathbf{A}}\in\mathbb{R}^{N_{\text{atom}}\times{N_{\text{atom}}}}$ and reference atomic relative distance matrix $\hat{\mathbf{M}}_{\hat{\mathbf{A}}}\in\mathbb{R}^{N_{\text{atom}}\times{N_{
\text{atom}}}}$.

The first loss is a direct MSE on the backbone (bb) positions,

$$ $\mathcal{L}_{\text{atom}}=\frac{1}{N}\|\mathbf{S}^{(0)}-\hat{\mathbf{S}}^{(0)} \|^{2},$ (10) $$

and the second loss is a local neighborhood loss on pairwise atomic distances,

$$ $\mathcal{L}_{\text{pairwise}}=\frac{1}{N^{2}}\|\mathbf{M}_{\mathbf{A}}^{(0)}- \hat{\mathbf{M}}_{\hat{\mathbf{A}}}^{(0)}\|^{2}.$ (11) $$

#### A.3.2 Additional details

##### Hyperparameters.

In training stage, we train the ProteinWeaver with the ”time batching” scheme described in Yim et al. (). In the ”time batching” scheme, each batch contains multiple time steps of a protein from a cluster. We set the weight of auxiliary losses to 0.25 and used a single represetation embedding dimension of 256, an pair represetation demension of 128. The learning rate is set to 0.0001. Moreover, we used ADAM (Kingma, ) as our optimizer. In the alignment stage, The learning rate is set to 0.00001 and SPPO beta is set to 1.0.

##### Training hardware setup.

ProteinWeaver is coded in PyTorch and was trained on 8 V100 32GB NVIDIA GPUs for 10 days.

### A.4 Inference details

During the inference process, when constructing the spliced distance map $\bar{\mathbf{M}}$, we introduced a linker of 15 amino acids in length, with the corresponding region in $\bar{\mathbf{M}}$ set to $-1$. We observed a significant enhancement in the flexibility of domain fusion upon the addition of the linker, particularly noticeable in the generation of short proteins. Additionally, during the inference stage, we set $\bar{\mathbf{M}}$ to a matrix with all elements as $-1$ when $t<0.2$. This adjustment similarly contributes to the quality of protein generation by the model.

### A.5 Evaluation Metrics

##### scTM and scRMSD.

The self consistency template modeling score (scTM) and the self consistency root-mean-square deviation (scRMSD) are two commonly used metrics for quality of protein backbone design.

Template Modeling score (TM-score) is a metric used in structural bioinformatics to assess the similarity between a predicted protein structure and a known target structure. the TM-score between a predicted structure $\textbf{T}_{\text{predicted}}\in\mathrm{SE(3)}^{L}$ and a target structure $\textbf{T}_{\text{target}}\in\mathrm{SE(3)}^{L}$ defined by

$$ $\text{TM-score}(\textbf{T}_{\text{predicted}},\textbf{T}_{\text{target}})=\max \Bigg{(}\frac{1}{L_{\text{target}}}\sum_{i=1}^{L_{\text{aligned}}}\frac{1}{1+ \left(\frac{d_{i}}{d_{0}}(L_{\text{target}})\right)^{2}}\Bigg{)},$ (12) $$

where $L_{\text{target}}$ is the length of the amino acid sequence of the target protein, and $L_{\text{common}}$ is the number of residues that appear in both the predicted and target structures. $d_{i}$ is the distance between the $i^{th}$ pair of residues in the predicted and target structures, and $d_{0}(L_{\text{target}})=1.24\sqrt[3]{L_{\text{target}}-15}-1.8$ is a distance scale that normalizes distances.

The root-mean-square deviation (RMSD) is a simple metric over paired residues defined by

$$ $\text{RMSD}(\textbf{T}_{\text{predicted}},\textbf{T}_{\text{target}})=\sqrt{ \frac{1}{L}\sum_{i=1}^{L}d_{i}^{2}},$ (13) $$

where $d_{i}^{2}$ is the distance between atom $i$ and either a reference structure or the mean position of the $L$ equivalent atoms. This is often calculated for the backbone heavy atoms C, N, O, and $\text{C}_{\alpha}$ or sometimes just the $\text{C}_{\alpha}$ atoms.

For a generated protein structure $\textbf{T}_{0}\in\mathrm{SE(3)}^{L}$, we apply ProteinMPNN (Dauparas et al., ) to sample multiple ($N_{\text{seq}}$) sequences. Each sequence is then folded with ESMFold (Lin et al., ) to obtain the target backbone $\hat{\textbf{T}}_{0}=[\textbf{T}_{1},\textbf{T}_{2},...,\textbf{T}_{N_{\text{
seq}}}]$ where $\textbf{T}_{i}\in\mathrm{SE(3)}^{L}$. The scTM score and scRMSD can be expressed for the generated protein structure $\textbf{T}_{0}$ and the target backbone $[\textbf{T}_{1},\textbf{T}_{2},...,\textbf{T}_{N_{\text{seq}}}]$ as

$$ $\text{scTM}(\textbf{T}_{0},\hat{\textbf{T}}_{0})=\max\left(\text{TM-score}( \textbf{T}_{0},\textbf{T}_{1}),\text{TM-score}(\textbf{T}_{0},\textbf{T}_{2}), ...,\text{TM-score}(\textbf{T}_{0},\textbf{T}_{N_{\text{seq}}})\right),$ (14) $$

$$ $\text{scRMSD}(\textbf{T}_{0},\hat{\textbf{T}}_{0})=\min\left(\text{RMSD}( \textbf{T}_{0},\textbf{T}_{1}),\text{RMSD}(\textbf{T}_{0},\textbf{T}_{2}),..., \text{RMSD}(\textbf{T}_{0},\textbf{T}_{N_{\text{seq}}})\right).$ (15) $$

Figure: Figure 8: Interface scTM and Interface scRMSD. Similar to computing the scTM score and scRMSD, to assess the quality of the domain-domain interface, we utilized ProteinMPNN and ESMFold to refold the given structure, segmented the interface structure, and calculated the scTM score and scRMSD of the interface structure before and after refolding.
Refer to caption: x7.png

##### Interface scTM and Interface scRMSD.

To better assess the rationality of interface design between generated protein domains, we introduced the interface scTM and interface scRMSD metric. For the generated protein $\textbf{T}_{0}$, we employed Unidoc to identify and partition its domains, selecting regions where the $C_{\alpha}$ distance between amino acids within domains was $<12\text{\r{A}}$ as interface $\textbf{I}_{0}$. Subsequently, utilizing ProteinMPNN and ESMFold, we refolded $N_{\text{seq}}$ interface structures $\hat{\textbf{I}}_{0}=[\textbf{I}_{1},\textbf{I}_{2},...,\textbf{I}_{N_{\text{
seq}}}]$ from $\textbf{T}_{0}$ and computed the scTM between $\textbf{I}_{0}$ and $\hat{\textbf{I}}_{0}$.

$$ $\text{Interface-scTM}(\textbf{T}_{0},\hat{\textbf{T}}_{0})=\max\left(\text{TM- score}(\textbf{T}_{0},\textbf{T}_{1}),...,\text{TM-score}(\textbf{T}_{0}, \textbf{T}_{N_{\text{seq}}})\right),$ (16) $$

$$ $\text{Interface-scRMSD}(\textbf{T}_{0},\hat{\textbf{T}}_{0})=\min\left(\text{ RMSD}(\textbf{T}_{0},\textbf{T}_{1}),...,\text{RMSD}(\textbf{T}_{0},\textbf{T} _{N_{\text{seq}}})\right).$ (17) $$

This approach allowed us to evaluate the quality of the designed interfaces within the generated protein, facilitating a comprehensive analysis of domain splicing-based protein backbone design. In the evaluation conducted in this study, we focused solely on structures with an scTM score $>0.5$ for the assessment of interface scTM. This approach is particularly advantageous for evaluating the model’s capability to interact with domains of higher design quality.

##### Max TM.

We calculate novelty using the maximum TM-score of designable generated proteins (scTM score $>0.7$) to the PDB data. To expedite the computation of metrics, in this study, we employed FoldSeek for protein structure compression and utilized foldseek easy-search to calculate TM score between the generated proteins and all proteins in the PDB database. This streamlined approach facilitated efficient assessment and comparison of protein structures, enhancing the speed and accuracy of our analysis in the domain splicing-based protein backbone design research.

##### Max Clust.

Proteins are usually gathered into different clusters during training. So for diversity, we use the number of generated clusters with a TM-score threshold of 0.5 of the generated samples as our diversity metric (higher is better). Similar to calculating Max TM, we utilized FoldSeek to compute diversity in our study. Specifically, we employed foldseek easy-cluster to perform clustering calculations on a set of proteins. This method allowed us to analyze and assess the diversity within protein structures efficiently. Note that in certain model, designability is inversely correlated with diversity as these models can produce unrealistic (e.g. unfolded) proteins that are “diverse” because they do not align well with each other.

### A.6 Tasks

##### Protein domain assembly.

In this study, we evaluated the model’s capability for domain assembly using domains from three distinct sources: (1) reassembling domains from native PDBs, (2) assembling randomly sampled native domains from CATH domains, and (3) assembling structures generated/synthesized by the backbone design models.

For the experiment involving the reassembly of domains of natural proteins, we curated a test set of 500 proteins from the multi-domain dataset of the Protein Data Bank (PDB). Specifically, we employed Unidoc to identify and partition the domains of these natural proteins, transforming them into spliced distance maps. Following model training, we used these spliced distance maps as conditions to generate corresponding proteins and computed their TM score and scTM score against actual natural proteins. The results indicated that ProteinWeaver has learned the assembly patterns of natural proteins.

In the experiment involving the splicing of CATH domains, we selected 500 proteins with distinct topological structures from the CATH dataset and constructed 10,000 novel splicing combinations using a random assembly approach. Subsequently, we tested these combinations using ProteinWeaver and further use SPPO for preference alignment.

Finally, we also assessed the performance of ProteinWeaver in assembling structures generated by different backbone design models. Notably, in this experiment, we did not filter the generated structures based on conditions. As a result, we observed that RFdiffusion, known for its stable generation quality, demonstrated superior performance across various lengths without conditional screening.

##### Protein backbone design.

For protein backbone design, we first generate domains of varying lengths using existing backbone design models like Chroma, RFdiffusion, and FrameFlow. Various models are used to obtain more diverse domain structures. We filter for domains with scTM score >0.8, then assemble them using ProteinWeaver.

In practice, this study only considered the results of assembling two domains during the inference stage. For instance, for a protein of length 500, we can decompose the backbone design into an assembly of a 200-length domain with a 300-length domain or an assembly of 100-length with 400-length. Initially, existing backbone design models were employed to generate fixed-length domains with scTM score >0.8. Subsequently, these two proteins were assembled together to complete the protein backbone design of length 500.

## Appendix B Additional Results

Figure: Figure 9: Domain statistics in designed backbone structures. We analyzed the domain composition of backbone structures designed using various methods and compared them to native proteins from RCSB PDB and SwissProt. Our findings reveal distinct trends in domain organization across different protein lengths and design approaches: (1) Native proteins: As protein length increases from 100 to 500 residues, we observe a natural trend of increasing domain numbers, typically ranging from 1 to 3 domains. (2) RFdiffusion and Chroma: These methods closely mimic nature’s trend, showing an increase in domain numbers as protein length grows. Other methods (FrameDiff, FrameFlow, ProteinDiff, and Genie): These approaches demonstrate limited capability in generating multi-domain backbones, deviating from the natural trend observed in native proteins. These results highlight the varying abilities of different backbone design methods to capture the complex domain architecture of proteins.
Refer to caption: x8.png

Figure: Figure 10: Domains undergo structural alterations after assembly using ProteinWeaver. (A) We analyzed the domain structure alterations between the stage 1 isolated state and the stage 2 assembled state using TM score and RMSD. Significant structural alterations can be observed after assembly. (B) Case study showing the detailed structural alterations. These results highlight ProteinWeaver’s capacity in flexible domain assembly.
Refer to caption: x9.png

**Table 1: Performance of ProteinWeaver on domain assembly using domains derived from native PDB structures and synthetic structures. Intf. quality metrics refer to the domain-domain assembly interface. Intf. is an abbreviation for interface. The reported results are the mean±std of repetitive experiments.**
|  | Native PDBs | Generated domain | CATH domain |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | Backbone Quality | Intf. Quality | Backbone Quality | Intf. Quality | Backbone Quality | Intf. Quality |  |  |  |  |  |  |
|  | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ |
| ProteinWeaver w/o alignment w/o refold | 0.63$\pm$0.14 | 7.48$\pm$3.97 | 0.67$\pm$0.15 | 5.00$\pm$1.38 | 0.77$\pm$0.16 | 3.55$\pm$3.78 | 0.73$\pm$0.13 | 4.12$\pm$0.84 | 0.55$\pm$0.15 | 10.62$\pm$3.99 | 0.58$\pm$0.10 | 5.73$\pm$1.26 |
| ProteinWeaver w/o alignment | 0.76$\pm$0.19 | 4.34$\pm$4.67 | 0.77$\pm$0.12 | 4.17$\pm$1.10 | 0.80$\pm$0.17 | 2.65$\pm$3.61 | 0.72$\pm$0.12 | 3.81$\pm$0.57 | 0.60$\pm$0.15 | 8.76$\pm$4.19 | 0.60$\pm$0.16 | 5.98$\pm$2.29 |
| ProteinWeaver-sft | 0.86$\pm$0.18 | 1.82$\pm$4.20 | 0.76$\pm$0.13 | 4.36$\pm$1.23 | 0.91$\pm$0.17 | 1.11$\pm$4.67 | 0.74$\pm$0.10 | 4.07$\pm$0.88 | 0.58$\pm$0.21 | 8.18$\pm$9.17 | 0.65$\pm$0.11 | 5.16$\pm$1.52 |
| ProteinWeaver w/o bo3 | 0.88$\pm$0.19 | 2.15$\pm$4.30 | 0.74$\pm$0.12 | 4.39$\pm$1.47 | 0.93$\pm$0.08 | 1.20$\pm$3.61 | 0.80$\pm$0.12 | 4.04$\pm$0.86 | 0.63$\pm$0.17 | 7.72$\pm$4.62 | 0.70$\pm$0.13 | 4.68$\pm$1.15 |

**Table 2: Performance of ProteinWeaver on domain assembly using domains derived from different backbone design models. The performance is evaluated without best of three filter. The reported results are the mean±std of repetitive experiments. We did not report the results of the Interface quality of length 100. This is because these methods only generates one single domain backbones identified by Unidoc. No multi-domain backbones are available for the evaluation. “Intf.” is an abbreviation for interface.**
|  | length 100 | length 200 | length 400 |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | Backbone Quality | Intf. Quality | Backbone Quality | Intf. Quality | Backbone Quality | Intf. Quality |  |  |  |  |  |  |
|  | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ |
| RFdiffusion | 0.95$\pm$0.03 | 0.78$\pm$0.03 | – | – | 0.95$\pm$0.06 | 1.07$\pm$1.07 | 0.81$\pm$0.07 | 3.69$\pm$0.13 | 0.74$\pm$0.17 | 5.41$\pm$4.26 | 0.75$\pm$0.13 | 4.24$\pm$1.13 |
| Chroma | 0.84$\pm$0.16 | 1.62$\pm$2.45 | – | – | 0.75$\pm$0.17 | 4.37$\pm$3.29 | 0.75$\pm$0.12 | 4.13$\pm$0.87 | 0.68$\pm$0.13 | 7.45$\pm$3.95 | 0.72$\pm$0.11 | 4.95$\pm$1.21 |
| FrameFlow | 0.84$\pm$0.14 | 1.61$\pm$1.94 | – | – | 0.75$\pm$0.15 | 3.18$\pm$2.98 | 0.70$\pm$0.13 | 3.84$\pm$0.55 | 0.64$\pm$0.16 | 8.09$\pm$4.31 | 0.73$\pm$0.11 | 4.29$\pm$0.87 |
| FrameDiff | 0.74$\pm$0.17 | 2.68$\pm$2.53 | – | – | 0.75$\pm$0.13 | 3.44$\pm$2.71 | 0.66$\pm$0.10 | 3.98$\pm$0.52 | 0.64$\pm$0.13 | 7.09$\pm$3.69 | 0.60$\pm$0.10 | 5.11$\pm$0.91 |

**Table 3: Performance of ProteinWeaver on backbone design models evaluated using various lengths ranging from 100 to 800. For each length, we randomly sampled 50 native PDB structures from RCSB as a golden reference for the task. The reported results are the mean±std of repetitive experiments. When the length is 100, the current backbone design model generates too few multi-domain proteins and is not statistically significant, so it is not reported.**
|  | length100 | length200 |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | Backbone Quality | Intf. Quality | Novelty | Diversity | Backbone Quality | Intf. Quality | Novelty | Diversity |  |  |  |  |
|  | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | Max TM ↓ | Max Clust ↑ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | Max TM ↓ | Max Clust ↑ |
| Native PDB | 0.96±0.10 | 0.67±1.61 | 0.82±0.17 | 0.75±0.34 | – | 0.77 | 0.97±0.08 | 0.67±1.37 | 0.85±0.18 | 0.98±1.15 | – | 0.79 |
| RFDiffusion | 0.98±0.05 | 0.48±0.56 | – | – | 0.80±0.08 | 0.32 | 0.95±0.09 | 1.07±1.41 | 0.89±0.13 | 1.43±1.65 | 0.68±0.07 | 0.64 |
| Chroma | 0.85±0.13 | 1.88±1.84 | – | – | 0.75±0.09 | 0.59 | 0.87±0.10 | 2.19±1.53 | 0.79±0.17 | 2.47±2.21 | 0.71±0.06 | 0.62 |
| FrameFlow | 0.92±0.08 | 1.06±0.94 | – | – | 0.76±0.07 | 0.49 | 0.91±0.11 | 1.79±2.24 | 0.86±0.04 | 3.66±0.26 | 0.69±0.08 | 0.80 |
| FrameDiff | 0.88±0.08 | 1.54±1.03 | – | – | 0.74±0.07 | 0.11 | 0.86±0.10 | 2.29±1.79 | 0.88±0.02 | 3.54±1.12 | 0.71±0.06 | 0.26 |
| ProteinWeaver w/o alignment w/o refold | 0.75±0.15 | 3.05±2.28 | 0.64±0.06 | 3.52±0.01 | 0.66±0.05 | 0.60 | 0.71±0.14 | 4.76±2.91 | 0.62±0.15 | 4.90±1.57 | 0.69±0.06 | 0.66 |
| ProteinWeaver w/o alignment | 0.90±0.14 | 1.26$\pm$1.97 | 0.73±0.07 | 3.96±0.71 | 0.61±0.07 | 0.60 | 0.86±0.11 | 2.59±3.70 | 0.71±0.15 | 4.29±1.19 | 0.66±0.06 | 0.68 |
| ProteinWeaver-sft | 0.91±0.13 | 1.19$\pm$1.79 | 0.73±0.07 | 3.59±0.23 | 0.62±0.06 | 0.61 | 0.86±0.12 | 2.61±2.44 | 0.75±0.14 | 4.16±1.09 | 0.67±0.06 | 0.68 |
| ProteinWeaver w/o bo3 | 0.91±0.14 | 1.27±1.84 | 0.75±0.14 | 3.96±0.78 | 0.61±0.07 | 0.59 | 0.88±0.13 | 2.47±3.63 | 0.73±0.14 | 4.22±1.03 | 0.65±0.07 | 0.67 |
| ProteinWeaver | 0.93±0.06 | 0.99±0.62 | 0.73±0.10 | 3.71±0.37 | 0.61±0.07 | 0.60 | 0.92±0.13 | 1.54±0.81 | 0.77±0.12 | 3.78±0.41 | 0.65±0.07 | 0.69 |
|  | length300 | length500 |  |  |  |  |  |  |  |  |  |  |
|  | Backbone Quality | Intf. Quality | Novelty | Diversity | Backbone Quality | Intf. Quality | Novelty | Diversity |  |  |  |  |
|  | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | Max TM ↓ | Max Clust ↑ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | Max TM ↓ | Max Clust ↑ |
| Native PDB | 0.97±0.10 | 0.82±2.67 | 0.92±0.09 | 1.11±1.45 | – | 0.77 | 0.97±0.17 | 1.07±5.96 | 0.88±0.17 | 2.23±3.54 | – | 0.8 |
| RFDiffusion | 0.89±0.15 | 2.65±3.15 | 0.91±0.11 | 1.65±2.04 | 0.69±0.05 | 0.65 | 0.76±0.19 | 6.71±5.53 | 0.80±0.17 | 4.51±3.98 | 0.67±0.04 | 0.89 |
| Chroma | 0.83±0.13 | 3.63±3.13 | 0.69±0.18 | 4.56±3.52 | 0.72±0.06 | 0.67 | 0.71±0.18 | 8.25±5.73 | 0.52±0.16 | 10.52±4.30 | 0.66±0.07 | 0.99 |
| FrameFlow | 0.84±0.15 | 3.56±3.46 | 0.78±0.15 | 4.95±2.28 | 0.72±0.07 | 0.88 | 0.66±0.19 | 9.78±5.82 | 0.69±0.17 | 8.20±3.57 | 0.67±0.09 | 0.92 |
| FrameDiff | 0.82±0.12 | 3.71±2.69 | 0.85±0.02 | 3.78±0.22 | 0.73±0.06 | 0.21 | 0.57±0.23 | 15.61±15.53 | 0.69±0.12 | 6.19±2.00 | 0.68±0.04 | 0.52 |
| ProteinWeaver w/o alignment w/o refold | 0.74±0.12 | 6.10±4.06 | 0.65±0.13 | 5.18±2.31 | 0.69±0.05 | 0.87 | 0.66±0.11 | 9.03±3.99 | 0.63±0.14 | 7.00±2.58 | 0.69±0.06 | 0.81 |
| ProteinWeaver w/o alignment | 0.86±0.10 | 3.16±2.40 | 0.71±0.16 | 4.48±1.60 | 0.67±0.06 | 0.86 | 0.78±0.14 | 5.77±4.36 | 0.68±0.15 | 5.87±2.93 | 0.67±0.06 | 0.76 |
| ProteinWeaver-sft | 0.86±0.10 | 3.15±2.20 | 0.74±0.15 | 4.21±1.22 | 0.68±0.06 | 0.85 | 0.72±0.14 | 8.30±3.19 | 0.69±0.09 | 7.15±2.93 | 0.72±0.07 | 0.89 |
| ProteinWeaver w/o bo3 | 0.88±0.13 | 2.47±3.63 | 0.74±0.07 | 4.29±1.99 | 0.67±0.06 | 0.86 | 0.82±0.10 | 4.39±2.72 | 0.70±0.14 | 5.14±1.77 | 0.67±0.07 | 0.78 |
| ProteinWeaver | 0.92±0.07 | 2.07±1.32 | 0.77±0.13 | 4.05±1.26 | 0.67±0.06 | 0.86 | 0.86±0.09 | 3.58±2.28 | 0.75±0.15 | 4.28±2.88 | 0.67±0.07 | 0.77 |
|  | length600 | length800 |  |  |  |  |  |  |  |  |  |  |
|  | Backbone Quality | Intf. Quality | Novelty | Diversity | Backbone Quality | Intf. Quality | Novelty | Diversity |  |  |  |  |
|  | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | Max TM ↓ | Max Clust ↑ | scTM ↑ | scRMSD ↓ | Intf. scTM ↑ | Intf. scRMSD ↓ | Max TM ↓ | Max Clust ↑ |
| Native PDB | 0.94±0.07 | 2.03±2.33 | 0.92±0.08 | 2.15±2.01 | – | 0.77 | 0.92±0.11 | 2.96±3.47 | 0.93±0.08 | 2.13±2.50 | – | 0.8 |
| RFDiffusion | 0.66±0.19 | 9.95±5.68 | 0.71±0.16 | 7.30±4.30 | 0.67±0.05 | 0.99 | 0.49±0.12 | 16.80±4.48 | 0.56±0.12 | 12.93±4.01 | 0.66±0.06 | 1.00 |
| Chroma | 0.62±0.17 | 11.40±5.91 | 0.48±0.12 | 12.97±4.08 | 0.67±0.06 | 1.00 | 0.62±0.14 | 12.75±6.13 | 0.47±0.12 | 14.88±4.37 | 0.68±0.07 | 1.00 |
| FrameFlow | 0.49±0.14 | 15.82±5.02 | 0.58±0.17 | 9.70±5.19 | 0.69±0.03 | 1.00 | 0.35±0.06 | 23.17±2.55 | 0.55±0.02 | 14.18±5.97 | 0.71±0.02 | 1.00 |
| FrameDiff | 0.45±0.08 | 16.19±3.35 | 0.53±0.10 | 10.63±2.44 | 0.72±0.03 | 1.00 | 0.38±0.06 | 20.50±3.29 | 0.48±0.10 | 12.20±4.49 | 0.71±0.03 | 1.00 |
| ProteinWeaver w/o alignment w/o refold | 0.57±0.13 | 12.43±4.66 | 0.61±0.14 | 8.28±3.01 | 0.70±0.07 | 0.74 | 0.45±0.08 | 18.56±3.53 | 0.52±0.10 | 13.04±3.39 | 0.70±0.06 | 0.74 |
| ProteinWeaver w/o alignment | 0.69±0.18 | 8.79±5.74 | 0.69±0.15 | 7.13±3.12 | 0.69±0.06 | 0.76 | 0.54±0.12 | 12.87±4.87 | 0.58±0.09 | 10.56±3.01 | 0.67±0.07 | 0.73 |
| ProteinWeaver-sft | 0.66±0.16 | 9.71±5.61 | 0.64±0.14 | 8.25±3.44 | 0.69±0.05 | 0.79 | 0.28±0.16 | 31.73±13.14 | 0.54±0.08 | 11.82±2.52 | 0.67±0.04 | 0.95 |
| ProteinWeaver w/o bo3 | 0.72±0.15 | 5.12±5.19 | 0.70±0.14 | 7.15±2.74 | 0.68±0.07 | 0.75 | 0.63±0.13 | 9.17±5.81 | 0.59±0.14 | 10.28±2.74 | 0.68±0.06 | 0.73 |
| ProteinWeaver | 0.79±0.12 | 4.95±3.44 | 0.71±0.15 | 6.86±2.89 | 0.68±0.07 | 0.76 | 0.68±0.11 | 8.72±4.60 | 0.60±0.11 | 9.98±2.70 | 0.67±0.06 | 0.73 |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. Please address the points in Weakness section.

2.  In the domain assembly generation stage, the authors indicate that a linker is inserted between adjacent domains, which may increase the overall protein length. How does the method ensure that the generated protein aligns with the target length?

3. What is the split configuration used during testing? Does the performance rely on this configuration? For example, assembling a 200-residue domain with a 300-residue domain for a target protein of 500 residues might yield different results compared to combining a 100-residue domain with a 400-residue domain.

4. Section 2.2 mentions that multi-domain proteins are filtered out, despite the method’s aim to model domain-domain interactions. What is the rationale behind excluding multi-domain proteins when they are essential for studying inter-domain interactions?
soundness: 2
strengths: The proposed method outperforms Chroma, RFDiffusion, FrameDiff, and FrameFlow in generating long backbone structures.
summary: The paper introduces ProteinWeaver, a two-stage framework for protein backbone design. In the first stage, individual protein domains are generated, and in the second stage, these domains are assembled using an SE(3) diffusion model. Additionally, the framework employs preference alignment to discern complex relationships between structural and interaction landscapes, aiming to enhance performance.
weaknesses: 1. The comparative evaluation is insufficient. While the authors emphasize that their method achieves superior performance on long proteins compared to Chroma and RFDiffusion, other recent methods—such as MultiFlow [1], CarbonNovo [2], Proteus [3], and FoldFlow2 [4]—have also demonstrated better performance on long proteins. To substantiate their claims and highlight the main contributions, the authors should include these methods in their comparisons.
2. The Related Work section does not adequately reflect the current literature on protein backbone generation. At a minimum, the methods mentioned in Weakness 1 should be discussed to provide a comprehensive overview of recent advancements.
3. I don't think the basic ideas are well-motivated. The proposed method assumes that any domains generated in the first stage can be assembled, which may not hold true concerning both function and structure. 
4. The methodology lacks sufficient novelty. It consists of two main components: a diffusion model for assembling domains and preference alignment to discern structural and interaction landscapes. Both components appear to be straightforward applications of well-established methods in the literature, raising concerns about the originality of the approach.

[1] Campbell et al. Generative Flows on Discrete State-Spaces: Enabling Multimodal Flows with Applications to Protein Co-Design. Proceedings of the 41st International Conference on Machine Learning. https://proceedings.mlr.press/v235/campbell24a.html

[2] Ren et al. CarbonNovo: Joint Design of Protein Structure and Sequence Using a Unified Energy-based Model. Proceedings of the 41st International Conference on Machine Learning. https://proceedings.mlr.press/v235/ren24e.html

[3] Wang et al. Proteus: Exploring Protein Structure Generation for Enhanced Designability and Efficiency. Proceedings of the 41st International Conference on Machine Learning. https://proceedings.mlr.press/v235/wang24bi.html

[4] Huguet et al.  Sequence-Augmented SE(3)-Flow Matching For Conditional Protein Backbone Generation. https://arxiv.org/abs/2405.20313

---

confidence: 4
contribution: 1
initial_rating: 3
presentation: 2
questions: line 245 typo maximine → maximize
soundness: 3
strengths: 1. First propose 2-stage generation framework for long protein design, which enables the generation of multiple (interacting) domains.
2. Suggest that generation of long proteins fall short due to lack of modeling inter-domain interaction; Reports the number of domains and interface scTM vs. native proteins. It is convincing and interesting argument.
summary: This work proposes a 2-stage protein backbone generation framework that assembles multiple domains using conditional diffusion model trained on diagonally concatenated distance map of individual domains. The authors perform preference alignment on scTM to further increase the quality of designs.
weaknesses: I believe the paper’s contribution can be divided into two aspects: a 2-stage generation approach and an alignment.

1. **2-stage generation approach:** **The results doesn’t really show that proposed 2-stage approach is effective.** To truly show that 2-stage assembly approach is better than 1-stage approach, I would compare ProteinWeaver vs scTM-aligned RFDiffusion, or ProteinWeaver w/o alignment vs. RFdiffusion. Any model can be additionally aligned to scTM, and it is not surprising that aligned model shows better results. 
    1. Appendix Table 3 shows the ProteinWeaver w/o alignment vs. RFdiffusion, and I think it is performing worse than RFDiffusion. sc metrics are only slightly better but diversity is much lower. It just seems like a tradeoff between diversity and designability.
2. **Alignment: Technical novelty and contribution is limited.** I believe preference alignment is already widely used in protein design tasks, and is more like a supplementary analysis within broader papers (as in FoldFlow2 [1]) not a full conference paper, especially when you don’t extensively discuss on an alignment method and draw meaningful discussions from them. The discussion on alignment method is weak, for example,
    1. Ablation study only compares with SFT. But in most cases SFT is precondition for later alignment not the standalone alignment method. How does SFT + PPO performs? [2] 
    2. SPPO and many preference alignment methods are tailored to model human preference, i.e. it is hard to decide an absolute, objective ‘preferredness’ of a response, so you bypass that via pairwise comparison. Can you clarify the reasoning behind the preference alignment when we have explicit reward function (i.e. scTM) we want to optimize?
3. **Results**: Even with this additional alignment, performance improvements are marginal. There is big decrease in diversity, and the designability cannot match those of the native PDBs. 
4. **Unclear writing**:
    1. line 199-200: 
        
        > To assemble generated domains, we utilize FrameDiff, the SE(3) diffusion model to pretrain the domain assembly model.
        > 
        
        My understanding is that ProteinWeaver uses FrameDiff architecture for domain assembly model. Is this correct? Could you revise this sentence and Appendix (line 690-693) to make it clear that ProteinWeaver uses FrameDiff architecture? Also do you use pretrained weights of FrameDiff?
        
    2. line245-246 Is it correct to say maximizing p(S) is different from maximizing the quality of generated structures? Isn’t native PDBs have high scTM and low scRMSD?

[1] Huguet, Guillaume, et al. "Sequence-Augmented SE (3)-Flow Matching For Conditional Protein Backbone Generation." arXiv preprint arXiv:2405.20313 (2024).
[2] Ethayarajh, Kawin, et al. Human-centered loss functions (halos). Technical report, Contextual AI, 2023.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: See weaknesses I've listed.
soundness: 3
strengths: - The divide-and-assembly strategy is a creative and effective method for protein backbone design, offering a new direction for protein engineering.
- The method shows significant improvements over current state-of-the-art, especially in the design of long-chain proteins, addressing a critical need in the field.
summary: The paper proposes an innovative framework for designing protein backbones. Inspired by natural protein evolution, the method divides the protein design problem into two stages: domain generation and assembly. ProteinWeaver demonstrates improved performance over existing methods, particularly for longer protein chains, and shows potential for designing proteins with cooperative functions.
weaknesses: - The paper could provide more insight into how robust ProteinWeaver is to variations in protein structures, especially those with atypical domain arrangements or those that deviate significantly from known protein families.
- While ProteinWeaver shows strong performance for long-chain proteins, it would be beneficial to see how it performs across a wider range of protein lengths, particularly shorter chains where domain assembly might be less complex but still challenging.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: - How does ProteinWeaver generalize in the wild? Did your method find any new interesting protein structures applicable to real problems?

Minor Comments:
- Figure 3 B: Rfdiffusion should have an uppercase F in the right plot.
- Sect. 2.3 could use some proofreading. The sentences in that paragraph are hard to read. E.g. “For each domain, we use f generates corresponding domain.”
soundness: 3
strengths: - The paper proposes a novel approach (to my knowledge) and evaluates the method empirically with promising results that should be considered for publication.
summary: The paper introduces ProteinWeaver, a method for protein design. The authors propose a two step “divide-and-assembly” approach, first generating local structures and then assembling them using a diffusion model which is fine-tuned with pairwise comparisons. They evaluate their model empirically and provide comparisons to other state-of-art approaches. They find that ProteinWeaver outperforms other approaches, especially for longer protein chains.
weaknesses: - The paper is mostly well written, however, due to a lot of condensed information, it can be hard to follow at some times and leaving a lot of details in the appendix.
- The authors did not perform a statistical analysis of their results. For example, in Table 3 some numbers are rather close. A test for statistical significance could strenghten the results.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: - In Appendix A.5, the description on the computation of scTM and scRMSD differs from the diagram in Figure 8. Could the authors clarify further on this? Is the ProteinMPNN-ESMFold pipeline used for refolding the backbone or the interface structure? 
- In Figure 3, why does assembly using PDB domain perform better than assembly using CATH domain? For assembly using PDB domain, does the model perform assembly using domains from the same PDB structure, leading to better performance over assembly using CATH domains? Moreover, for assembly with synthesized domains, does the model perform assembly using domains from the same synthesized structure? Why is the performance of assembly using RFDiffusion-generated domains better than that of PDB and CATH domains? How many structures are generated for each method? This same set of questions also applies for Figure 6.
- In Figure 1F, what is the scale on each axis?
- In line 257-265, what are the criteria used for deduplication and domain selection?
- In Section 3.5, it would be useful if the authors could provide further details on the refolding of domains. Specifically, to what extent is the structure altered in the refolding process? What is the self-consistency performance for initial domains (directly split from PDB) and refolded domains? Does the domain in the final assembly resemble more closely to the initial domain or the refolded domain?
- Could the authors provide further details on the best-of-3 filter? In Figure 7, the performance of ProteinWeaver without alignment and bo3 is close to the performance of ProteinWeaver. Interestingly, the performance of ProteinWeaver without alignment and bo3 seems to outperform the performance of ProteinWeaver without alignment (but with bo3 filter). Do the authors have any intuition on these observations? Moreover, the margin of benefits that alignment provides seems to be smaller than illustrated in Figure 6. It would be helpful if the authors could also show the performance of ProteinWeaver in Figure 6.
- For comparisons with backbone design models, it is worth noting that RFDiffusion is trained with a crop size of 384 residues, which is smaller than that used for training ProteinWeaver. This could give ProteinWeaver an edge in generating longer proteins since the training dataset consists of more long proteins. In addition, how does the model perform compared to Proteus (https://www.biorxiv.org/content/10.1101/2024.02.10.579791v1), which exhibits better generation performance on long proteins than RFDiffusion?
- For pretraining, does the model start from scratch or pretrained FrameDiff weights? Also, it would be helpful if the authors could provide further details on the training and sampling time: How long does it take to pretrain the model and how many epochs does it run? How long does it take to align the model?
- Figure 9: How does ProteinWeaver perform here?
- How does ProteinWeaver perform as the number of domains increases?
soundness: 2
strengths: The paper is generally clear and easy to understand. The concept of flexibly folding multiple domains is an interesting application of recent protein diffusion models and could be very useful for designing more complex functional proteins.
summary: This paper proposes a domain assembly framework, coupled with preference alignment, to flexibly assemble multiple protein domains, achieving better generation performance on long proteins compared to existing protein backbone design models.
weaknesses: Besides the limitations mentioned in Section 5, one major concern is the fairness of comparisons with other protein backbone models. Specifically, while other protein design models such as RFDiffusion and Chroma generate proteins from scratch (unconditional generation), ProteinWeaver performs a conditional generation task with substantial “local” information (individual domain structures) provided. This combines with observation that individual structures do not shift substantially (with mean alterations less than 2A as shown in Figure 10), suggesting that ProteinWeaver tackles an easier task compared to other protein backbone models and thus it is not a fair comparison with other models such as RFDiffusion and Chroma. In addition, details on the generation of samples that are used for comparison with other backbone design models are lacking, for example, what existing backbone design models are used for generation, how many domains are generated by each model, how the generation is decomposed (percentage of each decomposition) and so on. These details are also crucial for understanding the novelty argument in Section 3.3; in particular, to what extent is the improvement in novelty a result of higher novelty in the underlying domain pool, or a result of the assembly process?

Considering the limited technical novelty in model architecture (FrameDiff with minor adaptations), it would be helpful if the authors could provide more ablation analysis on the preference alignment component. For example, what is the effect of different reward assignments? How would the performance change if the preference considers more than just scTM, but also interface scTM and other metrics? How do various factors on the alignment dataset construction (for example, size, diversity in domain selection) affect model performance?