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,307 @@
+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
+import traceback
+# 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 _error(message):
+    """Return outputs that surface a clear error in the UI (results, download, status)."""
+    return None, None, gr.update(value=f"⚠️ **Input error:** {message}", visible=True)
+
+
+def render_results(results, threshold):
+    """Build the ranked table and clear any error. CSV is generated on-demand via download callback.
+
+    Pure post-processing: `results` is already sorted by Tm at prediction time, and the
+    threshold only controls the Yes/No label. Runs in well under a second with no model
+    inference. Returns the same (output, error_box) pair as the error/success paths so
+    every entry point owns the full result area.
+    """
+    clear_error = gr.update(value="", visible=False)
+    if not results:
+        # No predictions yet (e.g. threshold changed before any successful run).
+        return None, clear_error
+
+    cutoff = float(threshold)
+    table = [
+        [i + 1, r["id"], r["tm"], "Yes" if r["tm"] > cutoff else "No"]
+        for i, r in enumerate(results)
+    ]
+
+    return table, clear_error
+
+
+def generate_csv(results, threshold):
+    """Generate CSV file from predictions. Called on-demand when user clicks download."""
+    if not results:
+        return None
+
+    cutoff = float(threshold)
+    table = [
+        [i + 1, r["id"], r["tm"], "Yes" if r["tm"] > cutoff else "No"]
+        for i, r in enumerate(results)
+    ]
+
+    csv_buffer = StringIO()
+    writer = csv.writer(csv_buffer)
+    writer.writerow(["Rank", "ID", "Predicted Tm [°C]", f"Thermostable (threshold > {threshold}°C)"])
+    writer.writerows(table)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode="w", encoding="utf-8") as tmp:
+        tmp.write(csv_buffer.getvalue())
+        tmp_path = tmp.name
+
+    return tmp_path
+
+
+def predict_tm(seq_text, seq_file, threshold):
+    # predict_tm drives one extra output (results_state) beyond render_results, so every
+    # exit appends the cached-predictions slot — [] on any error, the predictions on success.
+    def error(message):
+        table, error_box = _error(message)[:2]
+        return table, error_box, ([],)
+
+    # --- Input validation (always returns clear messages) ---
+    if seq_file is not None:
+        try:
+            with open(seq_file.name, "r", encoding="utf-8") as f:
+                fasta_str = f.read()
+        except Exception as e:
+            return error(f"Could not read uploaded file: {str(e)}")
+    elif seq_text.strip():
+        fasta_str = seq_text
+    else:
+        return error("Please provide a sequence via text or file.")
+
+    try:
+        records = parse_fasta_string(fasta_str)
+    except Exception as e:
+        return error(f"FASTA parsing failed: {str(e)}")
+
+    if not records:
+        return error("No valid sequences found in the input (no FASTA records detected). "
+                     "Make sure each entry starts with a '>' header line.")
+
+    # --- Validate each sequence before inference ---
+    for record in records:
+        seq = record["sequence"].upper()
+        if len(seq) < 20:
+            return error(f"Sequence '{record['id']}' is too short ({len(seq)} amino acids). Minimum length is 20.")
+        if len(seq) > 2000:
+            return error(f"Sequence '{record['id']}' is too long ({len(seq)} amino acids). Maximum length is 2000.")
+        invalid_chars = set(seq) - VALID_AMINO_ACIDS
+        if invalid_chars:
+            return error(f"Invalid characters in sequence '{record['id']}': {''.join(sorted(invalid_chars))}. "
+                         f"Only standard amino acids (ACDEFGHIKLMNPQRSTVWY) are allowed.")
+
+    # --- Model inference (explicit try/except to surface meaningful error) ---
+    results = []
+    for i, record in enumerate(records, 1):
+        seq = record["sequence"].upper()
+        try:
+            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)})
+        except torch.cuda.OutOfMemoryError:
+            return error(f"GPU out-of-memory error while processing sequence '{record['id']}' "
+                         f"(length {len(seq)}). Try on CPU or reduce input size.")
+        except Exception as e:
+            return error(f"Model inference failed for sequence '{record['id']}': {str(e)}. "
+                         f"This may indicate an incompatibility between the model and the input.")
+
+    # Sort once here; the rank order is threshold-independent, so the cached results
+    # can be re-filtered on threshold changes without re-sorting.
+    results.sort(key=lambda x: x["tm"], reverse=True)
+
+    # --- Build output ---
+    try:
+        outputs = render_results(results, threshold)
+    except Exception as e:
+        return error(f"Failed to generate output: {str(e)}")
+
+    # Cache the sorted predictions so changing the threshold can re-filter without inference.
+    return outputs + (results,)
+
+
+# Override the theme's grey label / helper text directly (more reliable than CSS),
+# then use CSS only for the file-upload box sizing.
+theme = gr.themes.Origin().set(
+    body_text_color="#1f2937",
+    body_text_color_subdued="#374151",
+    block_label_text_color="#1f2937",
+    block_label_text_weight="700",
+    block_label_text_size="1rem",
+    block_title_text_color="#1f2937",
+    block_title_text_weight="700",
+    block_title_text_size="1rem",
+    block_info_text_color="#374151",
+)
+
+# Label / info text colors live in the theme tokens above. CSS is only for what no
+# theme token can express: the file-upload box size and its (inherited) inner font.
+CUSTOM_CSS = """
+#fasta_upload .wrap {
+    min-height: 110px !important;
+    font-size: 0.8rem !important;
+}
+"""
+
+demo = gr.Blocks(theme=theme, css=CUSTOM_CSS)
+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)<br>
+                        🐙 **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", height=120, elem_id="fasta_upload")
+            btn = gr.Button("Predict")
+
+            def toggle_input_visibility(txt, f):
+                if txt.strip():
+                    return gr.update(visible=False)
+                elif f is not None:
+                    return gr.update(visible=False)
+                else:
+                    return gr.update(visible=True)
+
+            # Text input and file upload share the space: using one hides the other,
+            # and clearing it brings the alternative back.
+            seq_text.input(
+                lambda txt: toggle_input_visibility(txt, None),
+                inputs=seq_text,
+                outputs=seq_file,
+            )
+            seq_file.change(
+                lambda f: toggle_input_visibility("", f),
+                inputs=seq_file,
+                outputs=seq_text,
+            )
+            cutoff_bins = [str(x) for x in range(20, 101, 10)]
+            cutoff_bar = gr.Radio(
+                choices=cutoff_bins,
+                label="Thermostability threshold (°C)",
+                info="Only affects the Yes/No label — Tm predictions are independent of this setting. Changing it re-filters existing results instantly, with no need to re-run the model.",
+                value="60"
+            )
+        with gr.Column(scale=4):
+            error_box = gr.Markdown(visible=False)
+            output = gr.Dataframe(headers=["Rank", "ID", "Predicted Tm [°C]", "Thermostable"], label="Results")
+            download_btn = gr.DownloadButton(label="Download CSV")
+    # Holds the raw per-sequence predictions from the last run, so changing the
+    # threshold can re-filter instantly without re-running the model.
+    results_state = gr.State([])
+    btn.click(
+        predict_tm,
+        inputs=[seq_text, seq_file, cutoff_bar],
+        outputs=[output, error_box, results_state]
+    )
+    # Changing the threshold only re-labels existing results — no inference. Shares the
+    # full result-area contract (incl. error_box) so a stale error banner is cleared too.
+    cutoff_bar.change(
+        render_results,
+        inputs=[results_state, cutoff_bar],
+        outputs=[output, error_box]
+    )
+    # Generate CSV on-demand when user clicks download, using current results and threshold.
+    download_btn.click(
+        generate_csv,
+        inputs=[results_state, cutoff_bar],
+        outputs=download_btn
+    )
+    with gr.Row():
+        examples = 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,
+        )
+        # An example fills the text box (and leaves the file empty), so restore the
+        # default split: text box visible, file upload hidden.
+        examples.dataset.click(
+            lambda: gr.update(visible=False),
+            outputs=seq_file,
+        )
+    with gr.Row():
+        with gr.Column(scale=1):
+            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
+            """
+            )
+        with gr.Column(scale=1):
+            gr.Markdown(value="""
+                ## 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
+            """
+            )
+
+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