README.md

---
dataset_info:
  features:
  - name: PDB_ID
    dtype: string
  - name: Entity_ID
    dtype: string
  - name: Chain
    dtype: string
  - name: Length
    dtype: int16
  - name: Fmax_eps-over-A
    dtype: float32
  - name: Fmax_pN
    dtype: float32
  - name: Dmax_A
    dtype: float32
  - name: Lmax_A
    dtype: float32
  - name: Lambda
    dtype: float32
  - name: Sequence
    dtype: string
  splits:
  - name: train
    num_bytes: 3212304
    num_examples: 16652
  - name: test
    num_bytes: 21731
    num_examples: 124
  download_size: 2217065
  dataset_size: 3234035
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
  - split: test
    path: data/test-*
---

# PRESTO: Rapid protein mechanical strength prediction with an end-to-end deep learning model

Proteins often form biomaterials with exceptional mechanical properties equal or even superior to synthetic materials. Currently, using experimental atomic force microscopy or computational molecular dynamics to evaluate protein mechanical strength remains costly and time-consuming, limiting large-scale de novo protein investigations. Therefore, there exists a growing demand for fast and accurate prediction of protein mechanical strength. To address this challenge, we propose PRESTO, a rapid end-to-end deep learning (DL) model to predict protein resistance to pulling directly from its sequence. By integrating a natural language processing model with simulation-based protein stretching data, we first demonstrate that PRESTO can accurately predict the maximal pulling force, for given protein sequences with unprecedented efficiency, bypassing the costly steps of conventional methods. Enabled by this rapid prediction capacity, we further find that PRESTO can successfully identify specific mutation locations that may greatly influence protein strength in a biologically plausible manner, such as at the center of polyalanine regions. Finally, we apply our method to design de novo protein sequences by randomly mixing two known sequences at varying ratios. Interestingly, the model predicts that the strength of these mixed proteins follows up- or down-opening “banana curves”, constructing a protein strength curve that breaks away from the general linear law of mixtures. By discovering key insights and suggesting potential optimal sequences, we demonstrate the versatility of PRESTO primarily as a screening tool in a rapid protein design pipeline. Thereby our model may offer new pathways for protein material research that requires analysis and testing of large-scale novel protein sets, as a discovery tool that can be complemented with other modeling methods, and ultimately, experimental synthesis and testing.

![image](https://cdn-uploads.huggingface.co/production/uploads/623ce1c6b66fedf374859fe7/kg7H9T2wgmKQD0lHZVPD4.png)

# Data, model and training

Load data

```python
import math
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from datasets import load_dataset

ds = load_dataset("lamm-mit/PRESTO-protein-force", split="train")

protein_df = ds.to_pandas()

print(protein_df.columns)
```

Scale data

```python
y_data = np.array(protein_df.Fmax_pN.values)
plt.scatter(range(y_data.shape[0]),y_data,s=2)
plt.xlabel('Sequence Number')
plt.ylabel('${F_{max}} (pN)$')
plt.savefig('data_view.png',dpi=500)
scalar=StandardScaler()
y_data_temp=np.reshape(y_data,(y_data.shape[0],1))
fit_data=scalar.fit(y_data_temp)  
mean=fit_data.mean_[0]  
std=math.sqrt(fit_data.var_)  
Y=scalar.fit_transform(y_data_temp)
```

Define tokenizer and model 

```python
# maximum length of sequence, longer the sequences, more time we need - 
max_length = 300

from tensorflow.keras.preprocessing.text import Tokenizer
tokenizer = Tokenizer(char_level=True)
tokenizer.fit_on_texts(seqs)
X = tokenizer.texts_to_sequences(seqs)
# if AA seq is longer than max_lenght will be discarded
X = sequence.pad_sequences(X, maxlen=max_length)
```

Split train/test

```python
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=.2,random_state=23)
```

Define model

```python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv1D, Flatten
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Embedding

model = Sequential()
model.add(Embedding(len(tokenizer.word_index)+1, embedding_dim, input_length=max_length))
model.add(Conv1D(filters=64, kernel_size=3, padding='same', activation='relu'))
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
model.add(tf.keras.layers.Bidirectional(keras.layers.LSTM(units=32,return_sequences=True)))
model.add(tf.keras.layers.Bidirectional(keras.layers.LSTM(units=16,return_sequences=True)))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mean_squared_error', optimizer='adam')
```

Train model 

```python
hist=model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=100, batch_size=128)
model.save('PRESTO.h5')
```

Plots
```
from tensorflow.keras.models import load_model
import itertools

model=load_model('PRESTO.h5')
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
plt.title('Sequence-to-Feature Model')
plt.scatter(y_train,y_train_pred,s=2)
plt.scatter(y_test,y_test_pred,c='r',s=2)
plt.xlabel('BSDB ${F_{max}}$ (pN)')
plt.ylabel('ML ${F_{max}}$ (pN)')
plt.legend(['training', 'validation'])
plt.savefig('train_comp.png',dpi=500)
```

![image](https://cdn-uploads.huggingface.co/production/uploads/623ce1c6b66fedf374859fe7/3FouBrLR1siS2xScemhke.png)


# Optimization examples

Fitness function

```python
def objective_value(input_seqs,fitness_fcn):
    tmp=tokenizer.texts_to_sequences(input_seqs)
    temp=sequence.pad_sequences(tmp, maxlen=max_length)
    y_pred=fitness_fcn.predict(temp)
    return y_pred

def iterate_mutate_no_target(sequences, targeta):
    list_list_seq = []
    for x in range(len(sequences)):
        list_list_seq.append(mutate_no_target(sequences[x], targeta))
    return list_list_seq

def iterate_calc(sequences):
    list_list_seq = []
    for x in sequences:
      list_list_seq.append((objective_value(x,fitness_fcn)*std+mean).flatten())
    return list_list_seq
```

Sample sequences
```python
prot_2c7w =     'HQRKVVSWIDVYTRATCQPREVVVPLTVELMGTVAKQLVPSCVTVQRCGGCCPDDGLECVPTGQHQVRMQILMIRYPSSQLGEMSLEEHSQCECRPKKK'
prot_2g38 =     'MSFVITNPEALTVAATEVRRIRDRAIQSDAQVAPMTTAVRPPAADLVSEKAATFLVEYARKYRQTIAAAAVVLEEFAHALTTGADKYATAEADNIKTFS'
prot_2g38_mut = 'MSFVITNPEALTVAATCVRRIRDRAIQSDAQGAPMTTAVRPCADLVSCGGACCFLGEYACKYGQTIAAAAVVLEEFAHALTTGADKYATAEACNCKTFS'
prot_1yn4=      'GKHTVPYTISVDGITALHRTYFVFPENKKVLYQEIDSKVKNELASQRGVTTEKINNAQTATYTLTLNDGNKKVVNLKKNDDAKNSIDPSTIKQIQIVVK'
prot_1kat=      'HHEVVKFMDVYQRSYCHPIETLVDIFQEYPDEIEYIFKPSCVPLMRCGGCCNDEGLECVPTEESNITMQIMRIKPHQGQHIGEMSFLQHNKCECRPKKD'
prot_1bmp=      'STGSKQRSQNRSKTPKNQEALRMANVAENSSSDQRQACKKHELYVSFRDLGWQDWIIAPEGYAAYYCEGECAFPLNSYMNATNHAIVQTLVHFINPETVPKPCCAPTQLNAISVLYFDDSSNVILKKYRNMVVRACGCH'
prot_1cdc=      'RDSGTVWGALGHGINLNIPNFQMTDDIDEVRWERGSTLVAEFKRKMKPFLKSGAFEILANGDLKIKNLTRDDSGTYNVTVYSTNGTRILDKALDLRILE'
```
```python
#mutates seq into poly-X (change AA and color)
ori =           'MNIFEMLRIDEGLRLKIYLDKAIGRNRAALVNLVFQIGETAAAAAAAAAAAAAAAAAAGAAGFTNSLRYLQQKRWDEAAVNFAKSRWYNQTPNRAKRIAAAAAAAAAAAAAAAAAAITVFRTGTWDAYKNL'
AA='T'
color='orange'
multiple_ori = []
mutated_seqs=[]
mutated_seqs_fmax=[]
num=100
for i in range(num):
    multiple_ori.append(ori)

mutated_seqs = iterate_mutate_no_target(multiple_ori, AA)
mutated_seqs_fmax = iterate_calc(mutated_seqs)
pd.DataFrame(mutated_seqs).to_csv("mutations_"+AA+".csv")
np.savetxt('mutations_'+AA+'_fmax.csv', mutated_seqs_fmax, delimiter=',')

for y in mutated_seqs_fmax:
    plt.plot(y,'0.7', zorder=0, linewidth=0.4)

transposed=np.transpose(mutated_seqs_fmax)
transposed_mean=[]
transposed_sd=[]

for x in transposed:
    transposed_mean.append(np.mean(x))
    transposed_sd.append(np.std(x))
```

Plot results

```python
plt.errorbar(range(len(transposed_mean)),transposed_mean,transposed_sd,capsize=2,zorder=50,color=color)
plt.xlabel('Number of mutations')
plt.ylabel('${F_{max}}$ (pN)')
plt.title(str(num)+' 1p3n sequences mutate towards poly-'+AA)
plt.plot(0,mutated_seqs_fmax[0][0],'or',zorder=100)
plt.plot(len(mutated_seqs[0])-1,mutated_seqs_fmax[0][len(mutated_seqs_fmax[0])-1],'or',zorder=100)
plt.savefig('mutations_'+AA+'.png',dpi=500)
```

![image](https://cdn-uploads.huggingface.co/production/uploads/623ce1c6b66fedf374859fe7/laM-07m_WywyEmFqV4B1I.png)

# Sample results

![image](https://cdn-uploads.huggingface.co/production/uploads/623ce1c6b66fedf374859fe7/L016VkdQ5vDUM1OJLLVyg.png)

![image](https://cdn-uploads.huggingface.co/production/uploads/623ce1c6b66fedf374859fe7/DZ-UwfEVI_3LeXsRiGxZF.png)

# Reference

```bibtex
@article{liu2022presto,
  title        = {{PRESTO}: Rapid protein mechanical strength prediction with an end-to-end deep learning model},
  author       = {Liu, Frank Y. C. and Ni, Bo and Buehler, Markus J.},
  journal      = {Extreme Mechanics Letters},
  volume       = {55},
  pages        = {101803},
  year         = {2022},
  publisher    = {Elsevier},
  doi          = {10.1016/j.eml.2022.101803},
}
```