Latest changes

.gitattributes

@@ -0,0 +1,2 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+venv
+.gradio
+__pycache__
+data.txt

README.md

@@ -0,0 +1,14 @@
+---
+title: Tmprot
+emoji: 💻
+colorFrom: yellow
+colorTo: pink
+sdk: gradio
+sdk_version: 5.43.1
+app_file: app.py
+pinned: true
+license: gpl-3.0
+short_description: 'Application for protein melting temperature prediction '
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,171 @@
+import gradio as gr
+import torch
+from pathlib import Path
+from helpers import load_model, parse_fasta_string
+from io import StringIO
+import csv
+import tempfile
+import transformers
+# mute esm warning for weights
+transformers.logging.set_verbosity_error()
+
+# Constants
+MODEL_NAME = "esm2_t33_650M_UR50D"
+CURRENT_DIR = Path(__file__).parent
+PATH_MODEL = CURRENT_DIR / "model"
+DEVICE = "cpu"
+# DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # arount 2 mins for fireprot
+VALID_AMINO_ACIDS = set("ACDEFGHIKLMNPQRSTVWY")
+
+model, tokenizer = load_model(MODEL_NAME, PATH_MODEL, DEVICE)
+
+def predict_tm(seq_text, seq_file, threshold):
+    if seq_file is not None:
+        with open(seq_file.name, "r", encoding="utf-8") as f:
+            fasta_str = f.read()
+    elif seq_text.strip():
+        fasta_str = seq_text
+    else:
+        return "Please provide a sequence via text or file."
+
+    try:
+        records = parse_fasta_string(fasta_str)
+    except Exception as e:
+        return f"FASTA parsing failed: {str(e)}"
+
+    if not records:
+        return "No valid sequences found."
+    
+    results = []
+    for i, record in enumerate(records, 1):
+        seq = record["sequence"].upper()
+        if len(seq) < 20:
+            return f"Sequence '{record['id']}' is too short (<20 amino acids)."
+        if len(seq) > 2000:
+            return f"Sequence '{record['id']}' is too long (>2000 amino acids)."
+
+        if not set(seq).issubset(VALID_AMINO_ACIDS):
+            invalid = "".join(set(seq) - VALID_AMINO_ACIDS)
+            return f"Invalid characters in sequence: {invalid}"
+        inputs = tokenizer(seq, return_tensors="pt", max_length=512, truncation=True, padding=True)
+        inputs = {k: v.to(DEVICE) for k, v in inputs.items()}
+        with torch.no_grad():
+            outputs = model(**inputs)
+            prediction = outputs.logits.squeeze().item()
+        results.append({"id": record["id"], "tm": round(prediction, 2)})
+    results_sorted = sorted(results, key=lambda x: x["tm"], reverse=True)
+    table = [
+        [i + 1, r["id"], r["tm"], "Yes" if r["tm"] > float(threshold) else "No"]
+        for i, r in enumerate(results_sorted)
+    ]
+    csv_buffer = StringIO()
+    writer = csv.writer(csv_buffer)
+    writer.writerow(["Rank", "ID", "Predicted Tm [°C]", f"Thermostable"])
+    writer.writerows(table)
+    csv_str = csv_buffer.getvalue()
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode="w", encoding="utf-8") as tmp:
+        tmp.write(csv_str)
+        tmp_path = tmp.name
+    return table, tmp_path
+
+demo = gr.Blocks(theme=gr.themes.Origin())
+with demo:
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Image("assets/TmProt_logo.png", width=100, height=100, show_label=False, show_download_button=False, container=False, show_share_button=False, show_fullscreen_button=False, interactive=False)
+        with gr.Column(scale=7):
+            gr.Markdown("""
+                        # TmProt
+                        ## Protein Thermostability Predictor
+                        """)
+            gr.Markdown(value="""
+                        ### TmProt is a machine-learning-based protein thermostability predictor that leverages a fine-tuned ESM-2 protein language model to estimate melting temperatures (Tm) of protein sequences. It enables users to upload protein sequences in FASTA format (either pasted as text or uploaded as a file), and outputs predicted Tm values ranked by a user-defined thermostability threshold.
+                        
+                        **Paper:** [https://doi.org/10.64898/2026.05.07.723192](https://doi.org/10.64898/2026.05.07.723192)  
+                        **GitHub:** [https://github.com/loschmidt/TmProt](https://github.com/loschmidt/TmProt)
+                        """
+                        )
+            
+        with gr.Column(scale=1):
+            gr.Image("assets/logo.png", width=100, height=100, show_label=False, show_download_button=False, container=False, show_share_button=False, show_fullscreen_button=False, interactive=False)
+    with gr.Row():
+        with gr.Column(scale=4):
+            seq_text = gr.Textbox(
+                label="FASTA sequences",
+                lines=6,
+                placeholder=">seq\nMKTIIALSYIFCLVFA",
+                value="",
+            )
+            seq_file = gr.File(label="Or upload FASTA file", file_types=[".fasta", ".fa", ".txt"], type="filepath")
+            btn = gr.Button("Predict")
+            cutoff_bins = [str(x) for x in range(20, 101, 10)]
+            cutoff_bar = gr.Radio(
+                choices=cutoff_bins,
+                label="Select thermostability threshold (°C)",
+                info="Default is 60°C",
+                value="60"
+            )
+        with gr.Column(scale=4):
+            output = gr.Dataframe(headers=["Rank", "ID", "Predicted Tm [°C]", "Thermostable"], label="Results")
+            download_btn = gr.DownloadButton(label="Download CSV")
+    btn.click(
+        predict_tm,
+        inputs=[seq_text, seq_file, cutoff_bar],
+        outputs=[output, download_btn]
+    )
+    with gr.Row():
+        gr.Examples(
+            examples = [
+            [""">I1W5V5
+MSIENLSSNKSFGGWHKQYSHVSNTLNCAMRFAIYLPPQASTGAKVPVLYWLSGLTCSDENFMQKAGAQRLAAELGIAIVAPDTSPRGEGVADDEGYDLGQGAGFYVNATQAPWNRHYQMYDYVVNELPELIESMFPVSDKRAIAGHSMGGHGALTIALRNPERYQSVSAFSPINNPVNCPWGQKAFTAYLGKDTDTWREYDASLLMRAAKQYVPALVDQGEADNFLAEQLKPEVLEAAASSNNYPLELRSHEGYDHSYYFIASFIEDHLRFHSNYLNA
+             """,
+                        None,           # seq_file is None (we use text)
+                        "60"            # threshold
+                    ],
+                    [  
+             """>R4YJ85
+MINLEKALAGRRILIVDDLVEARSSLKKMATILGGDNIDVATDGIEAMSLIHEHEYDIVLSDYNLGRTKDGQQILEEARFTQRLRATSLFIVITGENAIDMVMGALEYDPDGYITKPYTLNMLKERLIRIITIKEELRKVNKAIDLQKYDLAIKYCLEVLDSNPRLRLPASRILGQLLMRQKRFQQALKIYSQLLNERSVSWAKLGQAICIFKLGDPNSALALLNRALVDHPLYVQCYDWIAKILLTLDKPLEAQAALEKAIVISPKAVLRQMELGRIAYENGDMVTAEPAFKYSVRLGRFSCHKSAKNYLQFVRSAQALLINPKERQTQNKANEAFRALTELKQDFSDDKDSLFEASIVESKTHLKMENLDEAKRSANDAEDMLAKLECPKIDYKLQMTETFIETDQSVKAQKMIDELKSAELSDKQIIMLNRLDNDLNGEALKRHSTSLNDQGVSHYEKGELEEAIIAFDQATHYEQAGISVLLNSIQAKISLMERDSPDKKILKNVRSLLIRIGEIAKDDERFARYSRLRKTYDRLCRAAAK
+             """,
+                        None,
+                        "50"
+                    ],
+            ],
+            inputs=[seq_text, seq_file, cutoff_bar],
+            label="Click an example to try TmProt instantly",
+            examples_per_page=2,
+        )
+    with gr.Row():
+        with gr.Column(scale=1):
+                pass
+        with gr.Column(scale=7):
+            gr.Markdown(value="""
+                ## Features
+
+                    - Predict protein melting temperature (Tm) from amino acid sequences
+
+                    - Accepts input via FASTA text or FASTA file upload
+
+                    - Supports sequences from 20 to 2000 amino acids in length
+
+                    - Outputs a ranked table with predicted Tm and thermostability status based on user-chosen threshold
+
+                    - CSV download option for easy export and downstream analysis
+
+                ## Model Overview
+
+                    - Base Model: facebook/esm2_t33_650M_UR50D (650M parameters)
+
+                    - Fine-tuning method: LoRA (Low-Rank Adaptation) using PEFT framework
+
+                    - Task: Regression prediction of protein melting temperature (Tm)
+
+                    - Training Data: ProMelt dataset (merged Meltome Atlas + ProTherm) with ~45,000 protein sequences and experimental Tm values
+
+                    - Output: Single linear regression output neuron predicting Tm in °C
+            """
+            )
+        with gr.Column(scale=1):
+            pass            
+
+if __name__ == "__main__":
+    demo.launch(share=True, allowed_paths=['./assets'])

helpers.py

@@ -0,0 +1,38 @@
+############################################  IMPORTS  ###########################################################
+import torch
+from typing import Tuple, List, Dict
+from transformers import AutoTokenizer, EsmForSequenceClassification
+from peft import PeftModel
+from Bio import SeqIO
+from io import StringIO
+##################################################################################################################
+
+def load_model(
+    model_name: str, path_model: str, device: str
+) -> Tuple[torch.nn.Module, AutoTokenizer]:
+    """
+    Load the ESM model and the PEFT LoRA adapter, set to eval mode and freeze parameters.
+    Loading is done on-the-fly: take pre-trained ESM-2 and apply adapters (PeftModel.from_pretrained).
+    Args:
+        model_name (str): Name of the base ESM model (e.g., 'esm2_t33_650M_UR50D').
+        path_model (str): Path to the fine-tuned LoRA adapter.
+
+    Returns:
+        Tuple[torch.nn.Module, AutoTokenizer]: Loaded model and tokenizer.
+    """
+    esm_model = f"facebook/{model_name}"
+    tokenizer = AutoTokenizer.from_pretrained(esm_model)
+    base_model = EsmForSequenceClassification.from_pretrained(
+        esm_model, num_labels=1
+    ).to(device)
+    # peft_config = PeftConfig.from_pretrained(str(path_model), local_files_only=True)
+    model = PeftModel.from_pretrained(base_model, str(path_model), is_local=True, local_files_only=True).to(device)
+    model.eval()
+    for param in model.parameters():
+        param.requires_grad = False
+    return model, tokenizer
+
+def parse_fasta_string(fasta_str: str):
+    """Parse FASTA string into list of dicts with id and sequence."""
+    handle = StringIO(fasta_str)
+    return [{"id": rec.id, "sequence": str(rec.seq)} for rec in SeqIO.parse(handle, "fasta")]

model/README.md

@@ -0,0 +1,300 @@
+---
+base_model: facebook/esm2_t33_650M_UR50D
+library_name: peft
+tags:
+  - protein
+  - esm2
+  - regression
+  - thermostability
+  - LoRA
+  - peft
+license: lgpl-3.0
+---
+
+# ESM-2 Protein Thermostability Predictor (LoRA Fine-Tuned)
+
+This model is a parameter-efficient fine-tuned version of `facebook/esm2_t33_650M_UR50D` using the `PEFT` (`LoRA`) framework. The model is trained to predict protein thermostability (Tm) using the ProMelt dataset (combination of Meltome and ProTherm). The output is produced by a single neuron, albeit some modifications are planned such as MLP for Tm prediction. No additional fine-tuning using BRENDA was conducted. 
+
+The model uses a single output neuron for regression, though future improvements (e.g., replacing with an MLP head) are planned. 
+
+
+## Model Details
+
+### Model Description
+- **Base model:** facebook/esm2_t33_650M_UR50D (650M parameters)
+
+- **Fine-tuning method:** LoRA (Low-Rank Adaptation) using PEFT
+
+- **Task:** Protein thermostability prediction (regression)
+
+- **Data:** ProMelt dataset (train/val/test CSV files)
+
+- **Output layer:** Single linear regression head
+
+- **Library stack:** Hugging Face Transformers, PEFT, PyTorch, Accelerate, MLflow, DagsHub
+
+### Model Features
+
+- Parameter-efficient fine-tuning (LoRA) for memory and compute savings
+
+- Cosine learning rate schedule
+
+- Mixed precision (fp16) training via Accelerate
+
+- Early stopping and best model selection based on RMSE
+
+- Automatic MLflow logging and artifact tracking
+
+### Additional details
+
+- **Developed by:** Loschmidt Laboratories
+- **Model type:** Protein sequence regression model (ESM-2 backbone + LoRA adapter)
+- **Language(s) (NLP):** Protein sequences (amino acids as chars)
+- **License:** This project is licensed under the GNU Lesser General Public License v3.0.
+- **Finetuned from model:** facebook/esm2_t33_650M_UR50D
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [\[LL repo\]](https://git.loschmidt.cz/tmprot/tmprot-predictor)
+- **Paper [optional]:** [In progress]
+- **Demo [optional]:** [In progress]
+
+## Usage
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+```
+cd src/tmprot
+python cli.py -i ../../test/FIR.fasta -o ../../predictions/ -d "\t"
+```
+
+### Out-of-Scope Use
+The generated $Tm$-aware embeddings from optimized ESM2 model can be used as features for MLPRegressor. 
+
+## Bias, Risks, and Limitations
+Predictions do not generalize well outside the proteomics-based ProMelt dataset, thus the results on the independent sets are worse.
+Additionally:
+
+- It does not account for post-translational modifications or environmental factors (e.g., pH, salt, ions).
+
+### Recommendations
+- Use outputs in combination with experimental or domain expertise.
+
+- Consider ensemble methods or downstream MLP for robustness.
+
+## How to Get Started with the Model
+Prepare a FASTA file with your protein(s).
+
+Use the CLI to predict:
+
+    python cli.py -i path/to/input.fasta -o path/to/output_directory -d "\t"
+
+The output CSV file contains the following columns:
+```
+Protein_ID, Sequence, Predicted_Tm
+```
+
+For code integration, use the TmPredictor class in `src/tmprot/cli.py`.
+## Training Details
+
+### Training Data
+
+The model was trained on the ProMelt dataset — a curated combination of the Meltome Atlas and ProTherm datasets, containing protein sequences with experimentally measured melting temperatures using proteomics-based approaches. Sequences were filtered to remove duplicates and split into train/val/test sets with sequence identity = 25%. CSV were stored in `../data/promelt/`.
+
+### Training Procedure
+#### Preprocessing
+- Sequence longer than 2000 AAs were filtered out.
+- Sequences tokenized using ESM-2 tokenizer from Hugging Face Transformers.
+- Batched using `DefaultDataCollator` with dynamic padding.
+#### Training Hyperparameters
+
+| Parameter              | Value                        |
+|------------------------|------------------------------|
+| Model                  | facebook/esm2_t33_650M_UR50D |
+| LoRA rank              | 1                            |
+| LoRA alpha             | 1                            |
+| LoRA dropout           | 0.28                         |
+| Learning rate          | 4.92e-4                      |
+| Weight decay           | 1.56e-5                      |
+| Gradient clipping      | 0.805                        |
+| Batch size             | 4                            |
+| Epochs                 | 1                            |
+| Precision              | fp16 (mixed)                 |
+| Scheduler              | Cosine                       |
+| Optimizer              | AdamW                        |
+| Evaluation strategy    | Per epoch                    |
+| Save strategy          | Per epoch                    |
+| Best model selection   | Based on RMSE                |
+| Gradient checkpointing | Enabled                      |
+| MLflow tracking        | Enabled (via DagsHub)        |
+| Seed                   | 8893                         |
+
+- LoRA target modules: query, key, and value
+
+- Loss function: MSE loss (via Trainer for regression)
+
+- Evaluation metrics: RMSE, R2, Pearson, Spearman
+#### Speeds, Sizes, Times [optional]
+- ~4200 seconds for training and evaluation.
+- Inference speed: ~5 sec/protein 
+- 7.3M size for `model` folder with adapters and updated weights.
+
+## Evaluation
+
+The model was evaluated on training, validation, and test datasets using multiple regression metrics to assess performance in predicting protein thermostability (Tm). Evaluation was performed after training for one epoch, with early stopping based on the validation RMSE.
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+The test set consists of ~7300 proteins held out from ProMelt. Care was taken to ensure no >25% sequence identity with training samples.
+
+#### Factors
+
+[More Information Needed]
+
+#### Metrics
+- RMSE (Root Mean Square Error): Measures average prediction error magnitude.
+
+- R2 Score (Coefficient of Determination): Indicates the proportion of variance explained by the model.
+
+- PCC (Pearson's Correlation Coefficient): Measures linear correlation between predicted and actual Tm values.
+
+- SCC (Spearman's Correlation Coefficient): Measures monotonic relationship between predicted and actual Tm values.
+
+### Results
+#### Internal Evaluation Results (ProMelt Train/Val/Test)
+| **Metric**         | **Train** | **Validation** | **Test** |
+| ------------------ | --------: | -------------: | -------: |
+| **Loss**           |     31.14 |          34.94 |    39.48 |
+| **RMSE**           |      5.58 |           5.91 |     6.28 |
+| **R² Score**       |     0.685 |          0.656 |    0.687 |
+| **PCC (Pearson)**  |     0.828 |          0.810 |    0.830 |
+| **SCC (Spearman)** |     0.635 |          0.585 |    0.617 |
+| **Runtime (s)**    |   1602.62 |         178.19 |   337.08 |
+| **Samples/sec**    |     21.44 |          21.45 |    21.45 |
+| **Steps/sec**      |      5.36 |           5.37 |     5.36 |
+| **Epoch**          |         1 |              1 |        1 |
+
+#### Independent evaluation
+| **Dataset**       | **RMSE** | **R² Score** | **PCC (Pearson)** | **SCC (Spearman)** |
+| ----------------- | -------: | -----------: | ----------------: | -----------------: |
+| **BRENDA**        |    15.31 |        0.209 |            0.6693 |             0.5175 |
+| **FireProt**      |    14.01 |       0.0618 |            0.5802 |             0.4306 |
+| **ASR**           |     7.36 |      -0.0749 |            0.2226 |             0.2515 |
+| **CAS**           |     6.50 |        0.223 |            0.6330 |             0.4461 |
+| **HLD**           |     6.70 |       -0.232 |            0.3090 |             0.2722 |
+
+These metrics indicate that the model achieves good regression performance on the protein thermostability prediction task, with reasonable generalization from training to test data.
+
+#### Summary
+
+This model is a LoRA fine-tuned version of the ESM-2 PLM (facebook/esm2_t33_650M_UR50D) designed to predict protein thermostability (Tm) from sequence data. The training was conducted on the ProMelt dataset with a single output regression head. Evaluation shows consistent performance across training, validation, and test splits with RMSE around 5.6-6.3 and good correlation metrics (R2 ~0.65-0.69, PCC ~0.81-0.83). This model provides a lightweight, efficient solution for protein thermostability prediction with potential applications in protein engineering and stability screening.
+
+---
+
+## Model Examination [optional]
+
+Interpretability analyses for this model remain to be conducted. Future work may include:
+
+- Visualization of attention maps to identify sequence regions most relevant for thermostability.
+- Embedding space analysis to examine clustering of proteins by thermostability.
+
+  
+These studies will help illuminate how the LoRA adapters modulate the ESM-2 backbone to capture thermostability-related features.
+
+---
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** 10 GB part (MIG) A100
+- **Hours used:** ?
+- **Cloud Provider:** Metacentrum
+- **Compute Region:** Czech republic
+- **Carbon Emitted:** ?
+
+The use of LoRA parameter-efficient fine-tuning significantly reduces training time and energy consumption compared to full model fine-tuning, contributing to lower carbon footprint.
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+- **Backbone:** ESM-2 PLM with 650 million parameters  
+- **Fine-tuning:** LoRA adapters applied to attention query, key, and value modules  
+- **Output:** Single linear regression head predicting protein melting temperature (Tm)  
+- **Objective:** Minimize RMSE between predicted and measured Tm values
+
+### Compute Infrastructure
+
+Training utilized a single NVIDIA A100 GPU with mixed precision enabled via the Accelerate library to optimize memory and speed.
+
+
+#### Hardware
+
+- GPU: NVIDIA A100 10GB  
+- RAM: 16 GB  
+
+
+
+#### Software
+
+- Python 3.9+
+- PyTorch==2.5.1
+- transformers==4.47.1
+- pandas==2.2.3
+- accelerate==1.1.1
+- datasets==3.1.0
+- peft==0.13.2
+- scipy==1.14.1
+- scikit-learn==1.5.2
+- prettytable==3.12.0
+- mlflow==2.18.0
+- dagshub (latest stable)
+- optuna (latest stable)
+- seaborn==0.13.2
+
+
+## Citation [optional]
+Paper: In progress. A manuscript detailing this model's methodology and performance is currently being prepared and will be linked here once published.
+
+**BibTeX:**
+
+[TODO]
+
+**APA:**
+
+[TODO]
+
+## Glossary [optional]
+Tm (Melting Temperature): The temperature at which half of the protein denatures.
+
+LoRA (Low-Rank Adaptation): A parameter-efficient fine-tuning method that inserts trainable rank-decomposed matrices into each layer of the transformer.
+
+RMSE (Root Mean Squared Error): Common regression metric measuring average model prediction error.
+
+PCC (Pearson Correlation Coefficient): Measures the linear correlation between predicted and true values.
+
+SCC (Spearman Correlation Coefficient): Measures the rank correlation between predicted and true values.
+
+fp16 (Mixed Precision): A technique that uses 16-bit floating point numbers for faster and more memory-efficient training.
+
+## More Information [optional]
+
+For additional details, updates, and community discussion:
+
+Repository: https://git.loschmidt.cz/tmprot/tmprot-predictor
+## Model Card Authors [optional]
+- karen.pailozian@fnusa.cz
+- add contacts ...
+
+Loschmidt Laboratories (Masaryk University)
+## Model Card Contact
+Issue Tracker: https://git.loschmidt.cz/tmprot/tmprot-predictor/issues
+
+### Framework versions
+
+- PEFT 0.13.2

model/adapter_config.json

@@ -0,0 +1,33 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "facebook/esm2_t33_650M_UR50D",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 1,
+  "lora_dropout": 0.2793910667846842,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": [
+    "classifier",
+    "score"
+  ],
+  "peft_type": "LORA",
+  "r": 1,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "value",
+    "query",
+    "key"
+  ],
+  "task_type": "TOKEN_CLS",
+  "use_dora": false,
+  "use_rslora": false
+}

model/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7bef27e36de848973fe6b78864882f899c2ad59bd17100d7e9d0eac4c24ff85
+size 7605796

model/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "<cls>",
+  "eos_token": "<eos>",
+  "mask_token": "<mask>",
+  "pad_token": "<pad>",
+  "unk_token": "<unk>"
+}

model/tokenizer_config.json

@@ -0,0 +1,53 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<cls>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "<eos>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "32": {
+      "content": "<mask>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<cls>",
+  "eos_token": "<eos>",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "tokenizer_class": "EsmTokenizer",
+  "unk_token": "<unk>"
+}

model/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c922ec8f05bb769d8a866b0e2ca376e7ad800ada8814c7738724ebd6570df080
+size 5432

model/vocab.txt

@@ -0,0 +1,33 @@
+<cls>
+<pad>
+<eos>
+<unk>
+L
+A
+G
+V
+S
+E
+R
+T
+I
+D
+P
+K
+Q
+N
+F
+Y
+M
+H
+W
+C
+X
+B
+U
+Z
+O
+.
+-
+<null_1>
+<mask>

requirements.txt

@@ -0,0 +1,4 @@
+torch==2.5.1
+transformers==4.46.3
+peft==0.16.0
+biopython==1.85.0