--- library_name: transformers tags: [] --- # NOTE The GitHub with the implementation and requirements.txt can be found [here](https://github.com/Synthyra/FastPLMs.git) # Profluent-E1 [Synthyra's version of Profluent-E1](https://github.com/Synthyra/Profluent-E1-300M) is a faithful implementation of Profluent's [E1](https://www.profluent.bio/showcase/e1) models ([license](https://github.com/Profluent-AI/E1/tree/main?tab=License-1-ov-file)) that integrates Huggingface AutoModel compatability and nice embedding functionality. ## Use with 🤗 transformers ### Supported models ```python model_dict = { # Synthyra/Profluent-E1-150M 'Profluent-E1-150M': 'Profluent-Bio/E1-150m', # Synthyra/Profluent-E1-150M 'Profluent-E1-300M': 'Profluent-Bio/E1-300m', # Synthyra/Profluent-E1-150M 'Profluent-E1-600M': 'Profluent-Bio/E1-600m', } ``` ```python import torch from transformers import AutoModelForMaskedLM device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = AutoModelForMaskedLM.from_pretrained('Synthyra/Profluent-E1-150M', trust_remote_code=True, dtype=torch.bfloat16).eval().to(device) sequences = ['MPRTEIN', 'MSEQWENCE'] batch = model.prep_tokens.get_batch_kwargs(sequences, device=device) output = model(**batch) # get all hidden states with output_hidden_states=True print(output.logits.shape) # language modeling logits, (batch_size, seq_len, vocab_size), (2, 11, 34) print(output.last_hidden_state.shape) # last hidden state of the model, (batch_size, seq_len, hidden_size), (2, 11, 768) print(output.loss) # language modeling loss if you passed labels #print(output.hidden_states) # all hidden states if you passed output_hidden_states=True (in tuple) #print(outout.attentions) # all attention matrices if you passed output_attentions=True (in tuple) ``` Our E1 implementation also supports sequence and token level classification tasks like ESM2. Simply pass the number of labels during initialization. ```python from transformers import AutoModelForSequenceClassification, AutoModelForTokenClassification model = AutoModelForSequenceClassification.from_pretrained('Synthyra/Profluent-E1-150M', num_labels=2, trust_remote_code=True) logits = model(**batch, labels=labels).logits print(logits.shape) # (batch_size, num_labels), (2, 2) ``` E1 weights were trained in bf16 and are in bf16 by default. You can load them in the precision of your choosing by leveraging the dtype parameter: ```python import torch model = AutoModelForMaskedLM.from_pretrained('Synthyra/Profluent-E1-150M', trust_remote_code=True, dtype=torch.float) # fp32 ``` ## Embed entire datasets with no new code To embed a list of protein sequences **fast**, just call embed_dataset. Sequences are sorted to reduce padding tokens, so the initial progress bar estimation is usually much longer than the actual time it will take. Example: ```python embedding_dict = model.embed_dataset( sequences=[ 'MALWMRLLPLLALLALWGPDPAAA', ... # list of protein sequences ], batch_size=2, # adjust for your GPU memory max_len=512, # adjust for your needs full_embeddings=False, # if True, no pooling is performed embed_dtype=torch.float32, # cast to what dtype you want pooling_types=['mean', 'cls'], # more than one pooling type will be concatenated together sql=False, # if True, embeddings will be stored in SQLite database sql_db_path='embeddings.db', save=True, # if True, embeddings will be saved as a .pth file save_path='embeddings.pth', ) # embedding_dict is a dictionary mapping sequences to their embeddings as tensors for .pth or numpy arrays for sql ``` ``` model.embed_dataset() Args: sequences: List of protein sequences batch_size: Batch size for processing max_len: Maximum sequence length full_embeddings: Whether to return full residue-wise (True) embeddings or pooled (False) pooling_type: Type of pooling ('mean' or 'cls') sql: Whether to store embeddings in SQLite database - will be stored in float32 sql_db_path: Path to SQLite database Returns: Dictionary mapping sequences to embeddings, or None if sql=True Note: - If sql=True, embeddings can only be stored in float32 - sql is ideal if you need to stream a very large dataset for training in real-time - save=True is ideal if you can store the entire embedding dictionary in RAM - sql will be used if it is True and save is True or False - If your sql database or .pth file is already present, they will be scanned first for already embedded sequences - Sequences will be truncated to max_len and sorted by length in descending order for faster processing ``` ## Fine-tuning with 🤗 peft ```python model = AutoModelForSequenceClassification.from_pretrained('Synthyra/Profluent-E1-150M', num_labels=2, trust_remote_code=True) # these modules handle E1 attention layers target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"] lora_config = LoraConfig( r=8, # choose lora parameters to your liking lora_alpha=16, lora_dropout=0.01, bias="none", target_modules=target_modules, ) # Apply LoRA to the model model = get_peft_model(model, lora_config) # Unfreeze the classifier head for param in model.classifier.parameters(): param.requires_grad = True ``` For a more thourough example of fine-tuning, check out our example script [here](https://github.com/Synthyra/FastPLMs/blob/main/fine_tuning_example.py). ### Citation If you use any of this implementation or work please cite the following DOI and Profluent's paper. ``` @misc {FastPLMs, author = { Hallee, Logan and Bichara, David and Gleghorn, Jason P.}, title = { FastPLMs: Fast, efficient, protien language model inference from Huggingface AutoModel.}, year = {2024}, url = { https://huggingface.co/Synthyra/ESMplusplus_small }, DOI = { 10.57967/hf/3726 }, publisher = { Hugging Face } } ``` ``` @article{Jain_Beazer_Ruffolo_Bhatnagar_Madani_2025, title={E1: Retrieval-Augmented Protein Encoder Models}, url={https://www.biorxiv.org/content/early/2025/11/13/2025.11.12.688125}, DOI={10.1101/2025.11.12.688125}, journal={bioRxiv}, publisher={Cold Spring Harbor Laboratory}, author={Jain, Sarthak and Beazer, Joel and Ruffolo, Jeffrey A and Bhatnagar, Aadyot and Madani, Ali}, year={2025} } ```