Migrated from GitHub

data/LICENSE.md

@@ -0,0 +1,43 @@
+Protify License (BSD 3‑Clause with Additional Restrictions)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimers in full.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimers in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+4. **Commercial Modification & Sale Restriction** – The Software, in whole or in part, may **not** be modified *or* sold for commercial purposes. Commercial entities and individuals may, however, utilize the unmodified Software for internal or external commercial activities, subject to compliance with all other terms of this licence.
+
+5. **Attribution for Generated Molecules** – Any molecule or derivative generated—whether for commercial or non‑commercial use—using the outputs of the Protify system must include clear and conspicuous credit to **“Protify”** (e.g., “Molecule generated with the Protify system”). Such credit must appear in any publication, disclosure, promotional material, or commercial documentation in which the molecule is referenced, sold, transferred, or otherwise made available.
+
+6. **No Removal of Notices** – You must not remove, obscure, or alter any proprietary notices (including attribution or copyright notices) that appear in or on the Software or that accompany the outputs of the Protify system.
+
+---
+
+### DISCLAIMER & USER AGREEMENT
+
+Deep‑learning models, including those contained in the Protify system, generate outputs via advanced probabilistic algorithms that may be inaccurate, incomplete, or otherwise unsuitable for any given purpose. **By downloading, installing, or using the Software (including running any of its models), you acknowledge and agree that:**
+
+* **Assumption of Risk** – You assume full responsibility for verifying the accuracy, fitness, and safety of all outputs produced by the Software—including, without limitation, any molecular structures, sequences, annotations, or recommendations.
+* **No Professional Advice** – Outputs are provided for informational purposes only and do not constitute professional, scientific, medical, legal, or other advice. You must perform your own independent checks before relying on any output.
+* **Indemnity** – To the maximum extent permitted by law, you agree to indemnify, defend, and hold harmless the copyright holder and contributors from and against any and all claims, damages, losses, liabilities, costs, or expenses (including reasonable attorneys’ fees) arising out of or related to your use of the Software or its outputs.
+* **Compliance with Law** – You are solely responsible for ensuring that your use of the Software and its outputs complies with all applicable laws, regulations, and industry standards, including those relating to export control, intellectual‑property rights, and biosafety/biosecurity.
+
+---
+
+### WARRANTY DISCLAIMER
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS **“AS IS”** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, NO WARRANTY IS MADE THAT THE SOFTWARE OR ITS OUTPUTS WILL BE ACCURATE, COMPLETE, NON‑INFRINGING, OR FREE FROM DEFECTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, PROFITS, OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE OR ITS OUTPUTS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+### TERMINATION
+
+Failure to comply with any of the above conditions automatically terminates your rights under this licence. Upon termination, you must cease all use, distribution, and reproduction of the Software and permanently delete or destroy all copies in your possession or control.
+
+---
+
+Except as expressly modified above, all terms of the standard BSD 3‑Clause License remain in full force and effect.
+

data/docs/resource_listing.md

@@ -0,0 +1,101 @@
+# Listing Supported Models and Datasets
+
+Protify provides several ways to view and explore the supported models and datasets. This documentation explains how to use these features.
+
+## Using the README Toggle Sections
+
+The main README.md file contains expandable toggle sections for both models and datasets:
+
+- **Currently Supported Models**: Click the toggle to expand and see a complete table of models with their descriptions, sizes, and types.
+- **Currently Supported Datasets**: Click the toggle to expand and see a complete table of datasets with their descriptions, types, and tasks.
+
+## Command-Line Listing
+
+Protify provides command-line utilities for listing models and datasets with detailed information:
+
+### Listing Models
+
+To list all supported models with their descriptions:
+
+```bash
+# List all supported models
+python -m src.protify.base_models.get_base_models --list
+
+# To download standard models
+python -m src.protify.base_models.get_base_models --download
+```
+
+### Listing Datasets
+
+To list all supported datasets with their descriptions:
+
+```bash
+# List all datasets
+python -m src.protify.data.dataset_utils --list
+
+# Get information about a specific dataset
+python -m src.protify.data.dataset_utils --info EC
+```
+
+### Combined Listing
+
+For a combined view of both models and datasets:
+
+```bash
+# List both models and datasets
+python -m src.protify.resource_info --all
+
+# List only standard models and datasets
+python -m src.protify.resource_info --all --standard-only
+
+# List only models
+python -m src.protify.resource_info --models
+
+# List only datasets
+python -m src.protify.resource_info --datasets
+```
+
+## Programmatic Access
+
+You can also access model and dataset information programmatically:
+
+```python
+# For models
+from src.protify.resource_info import model_descriptions
+from src.protify.base_models.get_base_models import currently_supported_models, standard_models
+
+# Get information about a specific model
+model_info = model_descriptions.get('ESM2-150', {})
+print(f"Model: ESM2-150")
+print(f"Description: {model_info.get('description', 'N/A')}")
+print(f"Size: {model_info.get('size', 'N/A')}")
+print(f"Type: {model_info.get('type', 'N/A')}")
+
+# For datasets
+from src.protify.resource_info import dataset_descriptions
+from src.protify.data.supported_datasets import supported_datasets
+
+# Get information about a specific dataset
+dataset_info = dataset_descriptions.get('EC', {})
+print(f"Dataset: EC")
+print(f"Description: {dataset_info.get('description', 'N/A')}")
+print(f"Type: {dataset_info.get('type', 'N/A')}")
+print(f"Task: {dataset_info.get('task', 'N/A')}")
+```
+
+## Model Group Types
+
+Models in Protify are generally grouped into the following categories:
+
+1. **Protein Language Models**: Pre-trained models that have learned protein properties from large-scale sequence data (e.g., ESM2, ProtBert)
+2. **Baseline Controls**: Models with random weights for comparison (e.g., Random, Random-Transformer)
+
+## Dataset Group Types
+
+Datasets are categorized by their task types:
+
+1. **Multi-label Classification**: Datasets where each protein can have multiple labels (e.g., EC, GO-CC)
+2. **Classification**: Binary or multi-class classification tasks (e.g., DeepLoc-2, DeepLoc-10)
+3. **Regression**: Prediction of continuous values (e.g., enzyme-kcat, optimal-temperature)
+4. **Protein-Protein Interaction**: Tasks focused on protein interactions (e.g., human-ppi, gold-ppi)
+5. **Token-wise Classification/Regression**: Residue-level prediction tasks (e.g., SecondaryStructure-3)

data/probe_package_colab.ipynb

@@ -0,0 +1,497 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# OUT OF DATE - NEEDS TO BE UPDATED"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "mQ__d_petycW"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **1. Setup**\n",
+        "\n",
+        "#@markdown ### Identification\n",
+        "huggingface_username = \"Synthyra\"  #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "huggingface_token = \"\"            #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "wandb_api_key = \"\"                #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "synthyra_api_key = \"\"             #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "github_token = \"\"                 #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "\n",
+        "github_clone_path = f\"https://{github_token}@github.com/Synthyra/ProbePackageHolder.git\"\n",
+        "# !git clone {github_clone_path}\n",
+        "# %cd ProbePackageHolder\n",
+        "# !pip install -r requirements.txt --quiet\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#@title **2. Session/Directory Settings**\n",
+        "\n",
+        "import torch\n",
+        "import argparse\n",
+        "from types import SimpleNamespace\n",
+        "from base_models.get_base_models import BaseModelArguments, standard_benchmark\n",
+        "from data.hf_data import HFDataArguments\n",
+        "from data.supported_datasets import supported_datasets\n",
+        "from embedder import EmbeddingArguments\n",
+        "from probes.get_probe import ProbeArguments\n",
+        "from probes.trainers import TrainerArguments\n",
+        "from main import MainProcess\n",
+        "\n",
+        "\n",
+        "main = MainProcess(argparse.Namespace(), GUI=True)\n",
+        "\n",
+        "#@markdown **Paths**\n",
+        "\n",
+        "#@markdown These will be created automatically if they don't exist\n",
+        "\n",
+        "#@markdown **Log Directory**\n",
+        "log_dir = \"logs\"                            #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Results Directory**\n",
+        "results_dir = \"results\"                    #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Model Save Directory**\n",
+        "model_save_dir = \"weights\"                 #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Embedding Save Directory**\n",
+        "embedding_save_dir = \"embeddings\"          #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Download Directory**\n",
+        "#@markdown - Where embeddings are downloaded on Hugging Face\n",
+        "download_dir = \"Synthyra/mean_pooled_embeddings\"  #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "\n",
+        "main.full_args.hf_token = huggingface_token\n",
+        "main.full_args.wandb_api_key = wandb_api_key\n",
+        "main.full_args.synthyra_api_key = synthyra_api_key\n",
+        "main.full_args.log_dir = log_dir\n",
+        "main.full_args.results_dir = results_dir\n",
+        "main.full_args.model_save_dir = model_save_dir\n",
+        "main.full_args.embedding_save_dir = embedding_save_dir\n",
+        "main.full_args.download_dir = download_dir\n",
+        "main.full_args.replay_path = None\n",
+        "main.logger_args = SimpleNamespace(**main.full_args.__dict__)\n",
+        "main.start_log_gui()\n",
+        "\n",
+        "#@markdown Press play to setup the session:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "FFgNDvDAt0xp"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **2. Data Settings**\n",
+        "\n",
+        "#@markdown **Max Sequence Length**\n",
+        "max_length = 2048          #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Trim Sequences**\n",
+        "#@markdown - If true, sequences are removed if they are longer than the maximum length\n",
+        "#@markdown - If false, sequences are truncated to the maximum length\n",
+        "trim = False               #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Dataset Names**\n",
+        "#@markdown Valid options (comma-separated):\n",
+        "\n",
+        "#@markdown *Multi-label classification:*\n",
+        "\n",
+        "#@markdown - EC, GO-CC, GO-BP, GO-MF\n",
+        "\n",
+        "#@markdown *Single-label classification:*\n",
+        "\n",
+        "#@markdown - MB, DeepLoc-2, DeepLoc-10, solubility, localization, material-production, cloning-clf, number-of-folds\n",
+        "\n",
+        "#@markdown *Regression:*\n",
+        "\n",
+        "#@markdown - enzyme-kcat,temperature-stability, optimal-temperature, optimal-ph, fitness-prediction, stability-prediction, fluorescence-prediction\n",
+        "\n",
+        "#@markdown *PPI:*\n",
+        "\n",
+        "#@markdown - human-ppi, peptide-HLA-MHC-affinity\n",
+        "\n",
+        "#@markdown *Tokenwise:*\n",
+        "\n",
+        "#@markdown - SecondaryStructure-3, SecondaryStructure-8\n",
+        "dataset_names = \"EC, DeepLoc-2, DeepLoc-10, enzyme-kcat\"  #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "data_paths = [supported_datasets[name.strip()] for name in dataset_names.split(\",\") if name.strip()]\n",
+        "\n",
+        "main.full_args.data_paths = data_paths\n",
+        "main.full_args.max_length = max_length\n",
+        "main.full_args.trim = trim\n",
+        "main.data_args = HFDataArguments(**main.full_args.__dict__)\n",
+        "args_dict = {k: v for k, v in main.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}\n",
+        "main.logger_args = SimpleNamespace(**args_dict)\n",
+        "main.get_datasets()\n",
+        "\n",
+        "#@markdown Press play to load datasets:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "D1iMWkLzt8QM"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **3. Model Selection**\n",
+        "\n",
+        "#@markdown Comma-separated model names.\n",
+        "#@markdown If empty, defaults to `standard_benchmark`.\n",
+        "#@markdown Valid options (comma-separated):\n",
+        "#@markdown - `ESM2-8, ESM2-35, ESM2-150, ESM2-650`\n",
+        "#@markdown - `ESMC-300, ESMC-600`\n",
+        "#@markdown - `Random, Random-Transformer`\n",
+        "model_names = \"ESMC-300\"  #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "selected_models = [name.strip() for name in model_names.split(\",\") if name.strip()]\n",
+        "\n",
+        "if not selected_models:\n",
+        "    selected_models = standard_benchmark\n",
+        "\n",
+        "main.full_args.model_names = selected_models\n",
+        "main.model_args = BaseModelArguments(**main.full_args.__dict__)\n",
+        "args_dict = {k: v for k, v in main.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}\n",
+        "main.logger_args = SimpleNamespace(**args_dict)\n",
+        "main._write_args()\n",
+        "\n",
+        "#@markdown *Press play to choose models:*\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qHCDeczNt20y"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **4. Embedding Settings**\n",
+        "#@markdown **Batch size**\n",
+        "batch_size = 4                #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Number of dataloader workers**\n",
+        "#@markdown - We recommend 0 for small sets of sequences, but 4-8 for larger sets\n",
+        "num_workers = 0               #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Download embeddings from Hugging Face**\n",
+        "#@markdown - If there is a precomputed embedding type that's useful to you, it is probably faster to download it\n",
+        "#@markdown - HIGHLY recommended for CPU users\n",
+        "download_embeddings = False   #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Full residue embeddings**\n",
+        "#@markdown - If true, embeddings are saved as a matrix of shape `(L, d)`\n",
+        "#@markdown - If false, embeddings are pooled to `(d,)`\n",
+        "matrix_embed = False          #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Embedding Pooling Types**\n",
+        "#@markdown - If more than one is passed, embeddings are concatenated\n",
+        "#@markdown Valid options (comma-separated):\n",
+        "#@markdown - `mean, max, norm, median, std, var, cls, parti`\n",
+        "#@markdown - `parti` (pool parti) must be used on its own\n",
+        "embedding_pooling_types = \"mean, std\"  #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Embedding Data Type**\n",
+        "#@markdown - Embeddings are cast to this data type for storage\n",
+        "embed_dtype = \"float32\"       #@param [\"float32\",\"float16\",\"bfloat16\",\"float8_e4m3fn\",\"float8_e5m2\"]\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Save embeddings to SQLite**\n",
+        "#@markdown - If true, embeddings are saved to a SQLite database\n",
+        "#@markdown - They will be accessed on the fly by the trainer\n",
+        "#@markdown - This is HIGHLY recommended for matrix embeddings\n",
+        "#@markdown - If false, embeddings are saved to a .pth file but loaded all at once\n",
+        "sql = False                   #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "main.full_args.all_seqs = main.all_seqs\n",
+        "main.full_args.batch_size = batch_size\n",
+        "main.full_args.num_workers = num_workers\n",
+        "main.full_args.download_embeddings = download_embeddings\n",
+        "main.full_args.matrix_embed = matrix_embed\n",
+        "main.full_args.embedding_pooling_types = [p.strip() for p in embedding_pooling_types.split(\",\") if p.strip()]\n",
+        "if embed_dtype == \"float32\": main.embed_dtype = torch.float32\n",
+        "elif embed_dtype == \"float16\": main.embed_dtype = torch.float16\n",
+        "elif embed_dtype == \"bfloat16\": main.embed_dtype = torch.bfloat16   \n",
+        "elif embed_dtype == \"float8_e4m3fn\": main.embed_dtype = torch.float8_e4m3fn\n",
+        "elif embed_dtype == \"float8_e5m2\": main.embed_dtype = torch.float8_e5m2\n",
+        "else:\n",
+        "    print(f\"Invalid embedding dtype: {embed_dtype}. Using float32.\")\n",
+        "    main.embed_dtype = torch.float32\n",
+        "main.sql = sql\n",
+        "\n",
+        "\n",
+        "main.embedding_args = EmbeddingArguments(**main.full_args.__dict__)\n",
+        "args_dict = {k: v for k, v in main.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}\n",
+        "main.logger_args = SimpleNamespace(**args_dict)\n",
+        "main.save_embeddings_to_disk()\n",
+        "\n",
+        "#@markdown *Press play to embed sequences:*\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "K7R-Htvit9Ti"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **5. Probe Settings**\n",
+        "\n",
+        "#@markdown **Probe Type**\n",
+        "#@markdown - `linear`: a MLP for pooled embeddings\n",
+        "#@markdown - `transformer`: a transformer model for matrix embeddings\n",
+        "#@markdown - `retrievalnet`: custom combination of cross-attention and convolution for matrix embeddings\n",
+        "probe_type = \"linear\"     #@param [\"linear\", \"transformer\", \"retrievalnet\"]\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Tokenwise**\n",
+        "#@markdown - If true, the objective is to predict a property of each token (matrix embeddings only)\n",
+        "#@markdown - If false, the objective is to predict a property of the entire sequence (pooled embeddings OR matrix embeddings)\n",
+        "tokenwise = False         #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Pre-LayerNorm**\n",
+        "#@markdown - If true, a LayerNorm is applied as the first layer of the probe the probe\n",
+        "#@markdown - Typicall improves performance\n",
+        "pre_ln = True             #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Number of layers**\n",
+        "#@markdown - Number of hidden layers in the probe\n",
+        "#@markdown - Linear probes have 1 input layer and 2 output layers, so 1 layer is a 4 layer MLP\n",
+        "#@markdown - This refers to how many transformer blocks are used in the transformer probe\n",
+        "#@markdown - Same for retrievalnet probes\n",
+        "n_layers = 1              #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Hidden dimension**\n",
+        "#@markdown - The hidden dimension of the model\n",
+        "#@markdown - 2048 - 8192 is recommended for linear probes, 384 - 1536 is recommended for transformer probes\n",
+        "hidden_dim = 8192         #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Dropout**\n",
+        "#@markdown - Dropout rate for the probe\n",
+        "#@markdown - 0.2 is recommended for linear, 0.1 otherwise\n",
+        "dropout = 0.2             #@param {type:\"number\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Classifier dimension**\n",
+        "#@markdown - The dimension of the classifier layer (transformer, retrievalnet probes only)\n",
+        "classifier_dim = 4096     #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Classifier Dropout**\n",
+        "#@markdown - Dropout rate for the classifier layer\n",
+        "classifier_dropout = 0.2  #@param {type:\"number\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Number of heads**\n",
+        "#@markdown - Number of attention heads in models with attention\n",
+        "#@markdown - between `hidden_dim // 128` and `hidden_dim // 32` is recommended\n",
+        "n_heads = 4               #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Rotary Embeddings**\n",
+        "#@markdown - If true, rotary embeddings are used with attention layers\n",
+        "rotary = True             #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Probe Pooling Types**\n",
+        "#@markdown - If more than one is passed, embeddings are concatenated\n",
+        "#@markdown Valid options (comma-separated):\n",
+        "#@markdown - `mean, max, norm, median, std, var, cls`\n",
+        "#@markdown - Is how the transformer or retrievalnet embeddings are pooled for sequence-wise tasks\n",
+        "probe_pooling_types_str = \"mean, cls\"  #@param {type:\"string\"}\n",
+        "\n",
+        "probe_pooling_types = [p.strip() for p in probe_pooling_types_str.split(\",\") if p.strip()]\n",
+        "\n",
+        "main.full_args.probe_type = probe_type\n",
+        "main.full_args.tokenwise = tokenwise\n",
+        "main.full_args.pre_ln = pre_ln\n",
+        "main.full_args.n_layers = n_layers\n",
+        "main.full_args.hidden_dim = hidden_dim\n",
+        "main.full_args.dropout = dropout\n",
+        "main.full_args.classifier_dim = classifier_dim\n",
+        "main.full_args.classifier_dropout = classifier_dropout\n",
+        "main.full_args.n_heads = n_heads\n",
+        "main.full_args.rotary = rotary\n",
+        "main.full_args.probe_pooling_types = probe_pooling_types\n",
+        "\n",
+        "main.probe_args = ProbeArguments(**main.full_args.__dict__)\n",
+        "args_dict = {k: v for k, v in main.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}\n",
+        "main.logger_args = SimpleNamespace(**args_dict)\n",
+        "main._write_args()\n",
+        "\n",
+        "#@markdown ---\n",
+        "#@markdown Press play to configure the probe:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "8W4OYnn4uIyU"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **6. Training Settings**\n",
+        "\n",
+        "#@markdown **Use LoRA**\n",
+        "#@markdown - If true, LoRA on the base model\n",
+        "use_lora = False               #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Hybrid Probe**\n",
+        "#@markdown - If true, the probe is trained on frozen embeddings\n",
+        "#@markdown - Then, the base model is finetuned alongside the probe\n",
+        "hybrid_probe = False           #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Full Finetuning**\n",
+        "#@markdown - If true, the base model is finetuned for the task\n",
+        "full_finetuning = False        #@param {type:\"boolean\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Number of epochs**\n",
+        "num_epochs = 200               #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Trainer Batch Size**\n",
+        "#@markdown - The batch size for probe training\n",
+        "#@markdown - We recommend between 32 and 256 with some combination of this and gradient accumulation steps\n",
+        "trainer_batch_size = 64        #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Gradient Accumulation Steps**\n",
+        "gradient_accumulation_steps = 1  #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Learning Rate**\n",
+        "lr = 0.0001                    #@param {type:\"number\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Weight Decay**\n",
+        "#@markdown - If you are having issues with overfitting, try increasing this\n",
+        "weight_decay = 0.0             #@param {type:\"number\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "#@markdown **Early Stopping Patience**\n",
+        "#@markdown - We recommend keep the epcohs high and using this to gage convergence\n",
+        "patience = 10                   #@param {type:\"integer\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "main.full_args.use_lora = use_lora\n",
+        "main.full_args.hybrid_probe = hybrid_probe\n",
+        "main.full_args.full_finetuning = full_finetuning\n",
+        "main.full_args.num_epochs = num_epochs\n",
+        "main.full_args.trainer_batch_size = trainer_batch_size\n",
+        "main.full_args.gradient_accumulation_steps = gradient_accumulation_steps\n",
+        "main.full_args.lr = lr\n",
+        "main.full_args.weight_decay = weight_decay\n",
+        "main.full_args.patience = patience\n",
+        "\n",
+        "main.trainer_args = TrainerArguments(**main.full_args.__dict__)\n",
+        "args_dict = {k: v for k, v in main.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}\n",
+        "main.logger_args = SimpleNamespace(**args_dict)\n",
+        "main._write_args()\n",
+        "\n",
+        "#@markdown ---\n",
+        "#@markdown Press play to run the trainer:\n",
+        "main.run_nn_probe()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "GdAk8wxWuJWO"
+      },
+      "outputs": [],
+      "source": [
+        "#@title **7. Log Replay**\n",
+        "\n",
+        "#@markdown **Replay Path**\n",
+        "#@markdown - Replay everything from a log by passing the path to the log file\n",
+        "replay_path = \"\"  #@param {type:\"string\"}\n",
+        "#@markdown ---\n",
+        "\n",
+        "from logger import LogReplayer\n",
+        "replayer = LogReplayer(replay_path)\n",
+        "replay_args = replayer.parse_log()\n",
+        "replay_args.replay_path = replay_path\n",
+        "\n",
+        "for key, value in replay_args.__dict__.items():\n",
+        "    if key in main.full_args.__dict__:\n",
+        "        main.full_args[key] = value\n",
+        "\n",
+        "replayer.run_replay(main)\n",
+        "\n",
+        "#@markdown ---\n",
+        "#@markdown Press to replay logs:\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.8"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

data/pyproject.toml

@@ -0,0 +1,41 @@
+[tool.poetry]
+name = "Protify"
+version = "0.0.5"
+description = "Low code molecular property prediction"
+authors = ["Synthyra <[email protected]>"]
+keywords = ["plm, protein, transformer"]
+repository = "https://github.com/Synthyra/Protify"
+license = "Protify License"
+readme = "README.md"
+include = [
+    "LICENSE.md",
+    "README.md",
+]
+
+packages = [
+    { include = "protify", from = "src" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+torch = ">=2.5.1"
+torchvision = "*"
+transformers = ">=4.47"
+accelerate = ">=1.1.0"
+tf-keras = "*"
+tensorflow = "*"
+torchinfo = "*"
+torchmetrics = "*"
+scikit-learn = "*"
+scipy = "*"
+datasets = "*"
+einops = "*"
+numpy = "==1.26.1"
+networkx = ">=3.4.2"
+xgboost = "*"
+lightgbm = "*"
+pyfiglet = "*"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

data/requirements.txt

@@ -0,0 +1,20 @@
+torch>=2.5.1
+torchvision
+transformers>=4.47
+accelerate>=1.1.0
+peft
+tf-keras
+tensorflow
+torchinfo
+torchmetrics
+scikit-learn==1.5.0
+scipy>=1.13.1
+datasets
+einops
+numpy==1.26.4
+networkx>=3.4.2
+xgboost
+lightgbm
+pyfiglet
+seaborn>=0.13.2
+matplotlib>=3.9.0

data/setup_bioenv.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+# chmod +x setup_bioenv.sh
+# ./setup_bioenv.sh
+
+# Set up error handling
+set -e  # Exit immediately if a command exits with a non-zero status
+
+echo "Setting up Python virtual environment for Protify..."
+
+# Create virtual environment
+python3 -m venv ~/bioenv
+
+# Activate virtual environment
+source ~/bioenv/bin/activate
+
+# Update pip and setuptools
+echo "Upgrading pip and setuptools..."
+pip install --upgrade pip setuptools
+
+# Install torch and torchvision
+echo "Installing torch and torchvision..."
+pip install --force-reinstall torch torchvision --index-url https://download.pytorch.org/whl/cu126
+
+# Install requirements with force reinstall
+echo "Installing requirements"
+pip install -r requirements.txt
+
+# List installed packages for verification
+echo -e "\nInstalled packages:"
+pip list
+
+# Instructions for future use
+echo -e "\n======================="
+echo "Setup complete!"
+echo "======================="
+echo "To activate this environment in the future, run:"
+echo "    source ~/bioenv/bin/activate"
+echo ""
+echo "To deactivate the environment, simply run:"
+echo "    deactivate"
+echo ""
+echo "Your virtual environment is located at: ~/bioenv"
+echo "======================="
+

data/src/protify/base_models/__init__.py

@@ -0,0 +1,14 @@
+from .get_base_models import (
+    get_base_model,
+    get_base_model_for_training,
+    get_tokenizer,
+    currently_supported_models,
+    standard_models,
+    experimental_models,
+    BaseModelArguments
+)
+
+try:
+    from .model_descriptions import model_descriptions
+except ImportError:
+    model_descriptions = {} 

data/src/protify/base_models/amplify.py

@@ -0,0 +1,3 @@
+"""
+This is currently not supported
+"""

data/src/protify/base_models/ankh.py

@@ -0,0 +1,78 @@
+import torch
+import torch.nn as nn
+from typing import Optional, Union, List, Dict
+from transformers import T5EncoderModel, AutoTokenizer
+
+from .base_tokenizer import BaseSequenceTokenizer
+from .t5 import T5ForSequenceClassification, T5ForTokenClassification
+
+
+presets = {
+    'ANKH-Base': 'Synthyra/ANKH_base',
+    'ANKH-Large': 'Synthyra/ANKH_large',
+    'ANKH2-Large': 'Synthyra/ANKH2_large',
+}
+
+
+class ANKHTokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer):
+        super().__init__(tokenizer)
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        tokenized = self.tokenizer(sequences, **kwargs)
+        return tokenized
+
+
+class AnkhForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.plm = T5EncoderModel.from_pretrained(model_path)
+
+    def forward(
+            self,
+            input_ids: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if output_attentions:
+            out = self.plm(input_ids, attention_mask=attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.plm(input_ids, attention_mask=attention_mask).last_hidden_state
+
+
+def get_ankh_tokenizer(preset: str):
+    return ANKHTokenizerWrapper(AutoTokenizer.from_pretrained('Synthyra/ANKH_base'))
+
+
+def build_ankh_model(preset: str):
+    model_path = presets[preset]
+    model = AnkhForEmbedding(model_path).eval()
+    tokenizer = get_ankh_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_ankh_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = T5EncoderModel.from_pretrained(model_path).eval()
+    else:
+        if tokenwise:
+            model = T5ForTokenClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+        else:
+            model = T5ForSequenceClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+    tokenizer = get_ankh_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.ankh
+    model, tokenizer = build_ankh_model('ANKH-Base')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/base_tokenizer.py

@@ -0,0 +1,36 @@
+import torch
+from typing import List, Dict, Union
+
+
+class BaseSequenceTokenizer:
+    def __init__(self, tokenizer):
+        if tokenizer is None:
+            raise ValueError("Tokenizer cannot be None.")
+        self.tokenizer = tokenizer
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        # Default tokenizer args if not provided
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'max_length')
+        kwargs.setdefault('add_special_tokens', True)
+
+        return self.tokenizer(sequences, **kwargs)
+
+    @property
+    def vocab_size(self):
+        return self.tokenizer.vocab_size
+
+    @property
+    def pad_token_id(self):
+        return getattr(self.tokenizer, 'pad_token_id')
+
+    @property
+    def eos_token_id(self):
+        return getattr(self.tokenizer, 'eos_token_id')
+
+    @property
+    def cls_token_id(self):
+        return getattr(self.tokenizer, 'cls_token_id')
+    
+    def save_pretrained(self, save_dir: str):
+        self.tokenizer.save_pretrained(save_dir)

data/src/protify/base_models/dplm.py

@@ -0,0 +1,388 @@
+
+# Copyright (c) 2024 Bytedance Ltd. and/or its affiliates
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+This is a modified version of the DPLM model from https://github.com/bytedance/dplm/blob/main/src/byprot/models/lm/esm_dplm.py
+"""
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from typing import List, Optional, Tuple, Union, Dict
+from transformers.models.esm.modeling_esm import (
+    EsmAttention,
+    EsmSelfAttention,
+    EsmLayer,
+    EsmEncoder,
+    EsmModel,
+    EsmEmbeddings,
+    EsmPooler,
+    EsmContactPredictionHead,
+    EsmIntermediate,
+    EsmOutput,
+    EsmLMHead,
+    EsmForMaskedLM,
+    EsmSelfOutput,
+    EsmPreTrainedModel,
+    EsmForSequenceClassification,
+    EsmForTokenClassification,
+)
+from transformers import EsmTokenizer, AutoTokenizer
+from transformers.modeling_outputs import BaseModelOutputWithPoolingAndCrossAttentions
+
+from .base_tokenizer import BaseSequenceTokenizer
+
+
+MODEL_REGISTRY = {}
+
+def register_model(name):
+    def decorator(cls):
+        MODEL_REGISTRY[name] = cls
+        return cls
+    return decorator
+
+
+class ModifiedEsmSelfAttention(EsmSelfAttention):
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.FloatTensor] = None,
+        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        mixed_query_layer = self.query(hidden_states)
+
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        is_cross_attention = encoder_hidden_states is not None
+        
+        if is_cross_attention and past_key_value is not None:
+            # reuse k,v, cross_attentions
+            key_layer = past_key_value[0]
+            value_layer = past_key_value[1]
+            attention_mask = encoder_attention_mask
+        elif is_cross_attention:
+            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
+            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
+            attention_mask = encoder_attention_mask
+        elif past_key_value is not None:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
+            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
+        else:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        query_layer = query_layer * self.attention_head_size**-0.5
+        
+        if self.is_decoder:
+            past_key_value = (key_layer, value_layer)
+
+        if self.position_embedding_type == "rotary":
+            query_layer, key_layer = self.rotary_embeddings(query_layer, key_layer)
+
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            raise NotImplementedError
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            raise NotImplementedError
+        
+        query_layer = query_layer.contiguous()
+        key_layer = key_layer.contiguous()
+        value_layer = value_layer.contiguous()
+        context_layer = F.scaled_dot_product_attention(query_layer, key_layer, value_layer, attn_mask=attention_mask, scale=1.0)
+        
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(new_context_layer_shape)
+
+        # outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+        outputs = (context_layer,)
+
+        if self.is_decoder:
+            outputs = outputs + (past_key_value,)
+        return outputs
+    
+
+class ModifiedEsmAttention(EsmAttention):
+    def __init__(self, config):
+        nn.Module.__init__(self)
+        self.self = ModifiedEsmSelfAttention(config)
+        self.output = EsmSelfOutput(config)
+        self.pruned_heads = set()
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    
+class ModifiedEsmLayer(EsmLayer):
+    def __init__(self, config):
+        nn.Module.__init__(self)
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = ModifiedEsmAttention(config)
+        self.is_decoder = config.is_decoder
+        self.add_cross_attention = config.add_cross_attention
+        if self.add_cross_attention:
+            if not self.is_decoder:
+                raise RuntimeError(f"{self} should be used as a decoder model if cross attention is added")
+            self.crossattention = ModifiedEsmAttention(config)
+        self.intermediate = EsmIntermediate(config)
+        self.output = EsmOutput(config)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+
+class ModifiedEsmEncoder(EsmEncoder):
+    def __init__(self, config):
+        nn.Module.__init__(self)
+        self.config = config
+        self.layer = nn.ModuleList([ModifiedEsmLayer(config) for _ in range(config.num_hidden_layers)])
+        self.emb_layer_norm_after = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.gradient_checkpointing = False
+
+
+class ModifiedEsmModel(EsmModel):
+    def __init__(self, config, add_pooling_layer=True):
+        EsmPreTrainedModel.__init__(self, config)
+        self.config = config
+
+        self.embeddings = EsmEmbeddings(config)
+        self.encoder = ModifiedEsmEncoder(config)
+
+        self.pooler = EsmPooler(config) if add_pooling_layer else None
+
+        self.contact_head = EsmContactPredictionHead(
+            in_features=config.num_hidden_layers * config.num_attention_heads, bias=True
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+        
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        encoder_attention_mask: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if self.config.is_decoder:
+            use_cache = use_cache if use_cache is not None else self.config.use_cache
+        else:
+            use_cache = False
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        batch_size, seq_length = input_shape
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+        # past_key_values_length
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        if attention_mask is None:
+            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
+
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape)
+
+        # If a 2D or 3D attention mask is provided for the cross-attention
+        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
+        if self.config.is_decoder and encoder_hidden_states is not None:
+            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            if encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            # encoder_extended_attention_mask = None
+            encoder_extended_attention_mask = encoder_attention_mask
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        embedding_output = self.embeddings(
+            input_ids=input_ids,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            past_key_values_length=past_key_values_length,
+        )
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_mask=extended_attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_extended_attention_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = encoder_outputs[0]
+        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
+
+        if not return_dict:
+            return (sequence_output, pooled_output) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPoolingAndCrossAttentions(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            past_key_values=encoder_outputs.past_key_values,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+            cross_attentions=encoder_outputs.cross_attentions,
+        )
+
+
+@register_model('mlm_esm')
+class EsmForDPLM(EsmForMaskedLM):
+    def __init__(self, config, dropout=0.1):
+        tokenizer = AutoTokenizer.from_pretrained(config._name_or_path)
+        config.hidden_dropout_prob = dropout
+        
+        EsmPreTrainedModel.__init__(self, config)
+        self.esm = ModifiedEsmModel(config, add_pooling_layer=False)
+        self.lm_head = EsmLMHead(config)
+
+        self.init_weights()
+        
+        self.mask_id = tokenizer.mask_token_id
+        self.pad_id = tokenizer.pad_token_id
+        self.bos_id = tokenizer.cls_token_id
+        self.eos_id = tokenizer.eos_token_id
+        self.x_id = tokenizer._token_to_id['X']
+        
+        self.contact_head = None
+        self.tokenizer = tokenizer
+    
+    def forward(self,
+                input_ids,
+                attention_mask=None,
+                inputs_embeds=None,
+                decoder_input_ids=None,
+                decoder_attention_mask=None,
+                decoder_inputs_embeds=None,
+                labels=None,
+                output_attentions=None,
+                output_hidden_states=None,
+                return_dict=None,
+                encoder_hidden_states=None,
+                encoder_attention_mask=None,
+            ):
+        attention_mask = input_ids.ne(self.pad_id)
+        outputs = self.esm(
+            input_ids,
+            attention_mask=attention_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+        )
+        sequence_output = outputs[0]
+        logits = self.lm_head(sequence_output)
+        
+        result = {
+            "logits": logits,
+            "last_hidden_state": sequence_output,
+        }
+        return result
+
+
+presets = {
+    'DPLM-150': 'airkingbd/dplm_150m',
+    'DPLM-650': 'airkingbd/dplm_650m',
+    'DPLM-3B': 'airkingbd/dplm_3b',
+}
+
+
+class DPLMTokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer: EsmTokenizer):
+        super().__init__(tokenizer)
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        tokenized = self.tokenizer(sequences, **kwargs)
+        return tokenized
+
+
+class DPLMForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.dplm = EsmForDPLM.from_pretrained(model_path)
+
+    def forward(
+            self,
+            input_ids: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if output_attentions:
+            out = self.dplm(input_ids, attention_mask=attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.dplm(input_ids, attention_mask=attention_mask)['last_hidden_state']
+
+
+def get_dplm_tokenizer(preset: str):
+    return DPLMTokenizerWrapper(EsmTokenizer.from_pretrained('facebook/esm2_t6_8M_UR50D'))
+
+
+def build_dplm_model(preset: str):
+    model = DPLMForEmbedding(presets[preset]).eval()
+    tokenizer = get_dplm_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_dplm_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = EsmForDPLM.from_pretrained(model_path).eval()
+    else:
+        if tokenwise:
+            model = EsmForTokenClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+        else:
+            model = EsmForSequenceClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+    tokenizer = get_dplm_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.dplm
+    model, tokenizer = build_dplm_model('DPLM-150')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/esm2.py

@@ -0,0 +1,84 @@
+"""
+We use the FastESM2 implementation of ESM2, which is exactly equivalent but uses FlashAttention2.
+"""
+import torch
+import torch.nn as nn
+from typing import Optional, Union, List, Dict
+from transformers import EsmTokenizer
+
+from .FastPLMs.modeling_fastesm import FastEsmModel, FastEsmForSequenceClassification, FastEsmForTokenClassification
+from .base_tokenizer import BaseSequenceTokenizer
+
+
+presets = {
+    'ESM2-8': 'Synthyra/ESM2-8M',
+    'ESM2-35': 'Synthyra/ESM2-35M',
+    'ESM2-150': 'Synthyra/ESM2-150M',
+    'ESM2-650': 'Synthyra/ESM2-650M',
+    'ESM2-3B': 'Synthyra/ESM2-3B',
+    'DSM-150': 'GleghornLab/ESM_diff_150',
+    'DSM-650': 'GleghornLab/ESM_diff_650',
+}
+
+
+class ESM2TokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer: EsmTokenizer):
+        super().__init__(tokenizer)
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        tokenized = self.tokenizer(sequences, **kwargs)
+        return tokenized
+
+
+class FastEsmForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.esm = FastEsmModel.from_pretrained(model_path)
+
+    def forward(
+            self,
+            input_ids: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if output_attentions:
+            out = self.esm(input_ids, attention_mask=attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.esm(input_ids, attention_mask=attention_mask).last_hidden_state
+
+
+def get_esm2_tokenizer(preset: str):
+    return ESM2TokenizerWrapper(EsmTokenizer.from_pretrained('facebook/esm2_t6_8M_UR50D'))
+
+
+def build_esm2_model(preset: str):
+    model = FastEsmForEmbedding(presets[preset]).eval()
+    tokenizer = get_esm2_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_esm2_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = FastEsmModel.from_pretrained(model_path).eval()
+    else:
+        if tokenwise:
+            model = FastEsmForTokenClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+        else:
+            model = FastEsmForSequenceClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+    tokenizer = get_esm2_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.esm2
+    model, tokenizer = build_esm2_model('ESM2-8')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/esm3.py

@@ -0,0 +1,3 @@
+"""
+This is currently not supported
+"""

data/src/protify/base_models/esmc.py

@@ -0,0 +1,84 @@
+"""
+We use the ESM++ implementation of ESMC, which is exactly equivalent but offers batching.
+"""
+import torch
+import torch.nn as nn
+from typing import Optional, Union, List, Dict
+
+from .FastPLMs.modeling_esm_plusplus import (
+    ESMplusplusModel,
+    ESMplusplusForSequenceClassification,
+    ESMplusplusForTokenClassification,
+    EsmSequenceTokenizer
+)
+from .base_tokenizer import BaseSequenceTokenizer
+
+
+presets = {
+    'ESMC-300': 'Synthyra/ESMplusplus_small',
+    'ESMC-600': 'Synthyra/ESMplusplus_large',
+}
+
+
+class ESMTokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer: EsmSequenceTokenizer):
+        super().__init__(tokenizer)
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        tokenized = self.tokenizer(sequences, **kwargs)
+        return tokenized
+
+
+class ESMplusplusForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.esm = ESMplusplusModel.from_pretrained(model_path)
+
+    def forward(
+            self,
+            input_ids: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if output_attentions:
+            out = self.esm(input_ids, attention_mask=attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.esm(input_ids, attention_mask=attention_mask).last_hidden_state
+
+
+def get_esmc_tokenizer(preset: str):
+    tokenizer = EsmSequenceTokenizer()
+    return ESMTokenizerWrapper(tokenizer)
+
+
+def build_esmc_model(preset: str):
+    model = ESMplusplusForEmbedding(presets[preset]).eval()
+    tokenizer = get_esmc_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_esmc_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = ESMplusplusModel.from_pretrained(model_path).eval()
+    else:
+        if tokenwise:
+            model = ESMplusplusForTokenClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+        else:
+            model = ESMplusplusForSequenceClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+    tokenizer = get_esmc_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.esmc
+    model, tokenizer = build_esmc_model('ESMC-300')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/get_base_models.py

@@ -0,0 +1,215 @@
+from dataclasses import dataclass
+
+
+currently_supported_models = [
+    'ESM2-8',
+    'ESM2-35',
+    'ESM2-150',
+    'ESM2-650',
+    'ESM2-3B',
+    'Random',
+    'Random-Transformer',
+    'Random-ESM2-8',
+    'Random-ESM2-35', # same as Random-Transformer
+    'Random-ESM2-150',
+    'Random-ESM2-650',
+    'ESMC-300',
+    'ESMC-600',
+    'ESM2-diff-150',
+    'ESM2-diffAV-150',
+    'ProtBert',
+    'ProtBert-BFD',
+    'ProtT5',
+    'ProtT5-XL-UniRef50-full-prec',
+    'ProtT5-XXL-UniRef50',
+    'ProtT5-XL-BFD',
+    'ProtT5-XXL-BFD',
+    'ANKH-Base',
+    'ANKH-Large',
+    'ANKH2-Large',
+    'GLM2-150',
+    'GLM2-650',
+    'GLM2-GAIA',
+    'DPLM-150',
+    'DPLM-650',
+    'DPLM-3B',
+    'DSM-150',
+    'DSM-650',
+]
+
+standard_models = [
+    'ESM2-8',
+    'ESM2-35',
+    'ESM2-150',
+    'ESM2-650',
+    'ESM2-3B',
+    'ESMC-300',
+    'ESMC-600',
+    'ProtBert',
+    'ProtT5',
+    'GLM2-150',
+    'GLM2-650',
+    'ANKH-Base',
+    'ANKH-Large',
+    'DPLM-150',
+    'DPLM-650',
+    'DSM-150',
+    'DSM-650',
+    'Random',
+    'Random-Transformer',
+]
+
+experimental_models = []
+
+
+@dataclass
+class BaseModelArguments:
+    def __init__(self, model_names: list[str] = None, **kwargs):
+        if model_names[0] == 'standard':
+            self.model_names = standard_models
+        elif 'exp' in model_names[0].lower():
+            self.model_names = experimental_models
+        else:
+            self.model_names = model_names
+
+
+def get_base_model(model_name: str):
+    if 'random' in model_name.lower():
+        from .random import build_random_model
+        return build_random_model(model_name)
+    elif 'esm2' in model_name.lower() or 'dsm' in model_name.lower():
+        from .esm2 import build_esm2_model
+        return build_esm2_model(model_name)
+    elif 'esmc' in model_name.lower():
+        from .esmc import build_esmc_model
+        return build_esmc_model(model_name)
+    elif 'protbert' in model_name.lower():
+        from .protbert import build_protbert_model
+        return build_protbert_model(model_name)
+    elif 'prott5' in model_name.lower():
+        from .prott5 import build_prott5_model
+        return build_prott5_model(model_name)
+    elif 'ankh' in model_name.lower():
+        from .ankh import build_ankh_model
+        return build_ankh_model(model_name)
+    elif 'glm' in model_name.lower():
+        from .glm import build_glm2_model
+        return build_glm2_model(model_name)
+    elif 'dplm' in model_name.lower():
+        from .dplm import build_dplm_model
+        return build_dplm_model(model_name)
+    else:
+        raise ValueError(f"Model {model_name} not supported")
+
+
+def get_base_model_for_training(model_name: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    if 'esm2' in model_name.lower() or 'dsm' in model_name.lower():
+        from .esm2 import get_esm2_for_training
+        return get_esm2_for_training(model_name, tokenwise, num_labels, hybrid)
+    elif 'esmc' in model_name.lower():
+        from .esmc import get_esmc_for_training
+        return get_esmc_for_training(model_name, tokenwise, num_labels, hybrid)
+    elif 'protbert' in model_name.lower():
+        from .protbert import get_protbert_for_training
+        return get_protbert_for_training(model_name, tokenwise, num_labels, hybrid)
+    elif 'prott5' in model_name.lower():
+        from .prott5 import get_prott5_for_training
+        return get_prott5_for_training(model_name, tokenwise, num_labels, hybrid)
+    elif 'ankh' in model_name.lower():
+        from .ankh import get_ankh_for_training
+        return get_ankh_for_training(model_name, tokenwise, num_labels, hybrid)
+    elif 'glm' in model_name.lower():
+        from .glm import get_glm2_for_training
+        return get_glm2_for_training(model_name, tokenwise, num_labels, hybrid)
+    elif 'dplm' in model_name.lower():
+        from .dplm import get_dplm_for_training
+        return get_dplm_for_training(model_name, tokenwise, num_labels, hybrid)
+    else:
+        raise ValueError(f"Model {model_name} not supported")
+
+
+def get_tokenizer(model_name: str):
+    if 'esm2' in model_name.lower() or 'random' in model_name.lower() or 'dsm' in model_name.lower():
+        from .esm2 import get_esm2_tokenizer
+        return get_esm2_tokenizer(model_name)
+    elif 'esmc' in model_name.lower():
+        from .esmc import get_esmc_tokenizer
+        return get_esmc_tokenizer(model_name)
+    elif 'protbert' in model_name.lower():
+        from .protbert import get_protbert_tokenizer
+        return get_protbert_tokenizer(model_name)
+    elif 'prott5' in model_name.lower():
+        from .prott5 import get_prott5_tokenizer
+        return get_prott5_tokenizer(model_name)
+    elif 'ankh' in model_name.lower():
+        from .ankh import get_ankh_tokenizer
+        return get_ankh_tokenizer(model_name)
+    elif 'glm' in model_name.lower():
+        from .glm import get_glm2_tokenizer
+        return get_glm2_tokenizer(model_name)
+    elif 'dplm' in model_name.lower():
+        from .dplm import get_dplm_tokenizer
+        return get_dplm_tokenizer(model_name)
+    else:
+        raise ValueError(f"Model {model_name} not supported")
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.get_base_models
+    import sys
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Download and list supported models')
+    parser.add_argument('--download', action='store_true', help='Download all standard models')
+    parser.add_argument('--list', action='store_true', help='List all supported models with descriptions')
+    args = parser.parse_args()
+    
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)
+        
+    if args.list:
+        try:
+            from resource_info import model_descriptions
+            print("\n=== Currently Supported Models ===\n")
+            
+            max_name_len = max(len(name) for name in currently_supported_models)
+            max_type_len = max(len(model_descriptions.get(name, {}).get('type', 'Unknown')) for name in currently_supported_models if name in model_descriptions)
+            max_size_len = max(len(model_descriptions.get(name, {}).get('size', 'Unknown')) for name in currently_supported_models if name in model_descriptions)
+            
+            # Print header
+            print(f"{'Model':<{max_name_len+2}}{'Type':<{max_type_len+2}}{'Size':<{max_size_len+2}}Description")
+            print("-" * (max_name_len + max_type_len + max_size_len + 50))
+            
+            for model_name in currently_supported_models:
+                if model_name in model_descriptions:
+                    model_info = model_descriptions[model_name]
+                    print(f"{model_name:<{max_name_len+2}}{model_info.get('type', 'Unknown'):<{max_type_len+2}}{model_info.get('size', 'Unknown'):<{max_size_len+2}}{model_info.get('description', 'No description available')}")
+                else:
+                    print(f"{model_name:<{max_name_len+2}}{'Unknown':<{max_type_len+2}}{'Unknown':<{max_size_len+2}}No description available")
+                    
+            print("\n=== Standard Models ===\n")
+            for model_name in standard_models:
+                print(f"- {model_name}")
+                
+        except ImportError:
+            print("Model descriptions file not found. Only listing model names.")
+            print("\n=== Currently Supported Models ===\n")
+            for model_name in currently_supported_models:
+                print(f"- {model_name}")
+                
+            print("\n=== Standard Models ===\n")
+            for model_name in standard_models:
+                print(f"- {model_name}")
+    
+    if args.download:
+        ### This will download all standard models
+        from torchinfo import summary
+        from ..utils import clear_screen
+        download_args = BaseModelArguments(model_names=['standard'])
+        for model_name in download_args.model_names:
+            model, tokenizer = get_base_model(model_name)
+            print(f'Downloaded {model_name}')
+            tokenized = tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICLLLICIIVMLL', return_tensors='pt').input_ids
+            summary(model, input_data=tokenized)
+            clear_screen()

data/src/protify/base_models/glm.py

@@ -0,0 +1,90 @@
+import torch
+import torch.nn as nn
+from typing import Optional, Tuple, Union, List, Dict
+from transformers import AutoTokenizer, AutoModel, AutoModelForTokenClassification, AutoModelForSequenceClassification
+
+from .base_tokenizer import BaseSequenceTokenizer
+
+
+presets = {
+    'GLM2-150': 'tattabio/gLM2_150M',
+    'GLM2-650': 'tattabio/gLM2_650M',
+    'GLM2-GAIA': 'tattabio/gLM2_650M_embed'
+}
+
+
+class GLMTokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer: AutoTokenizer):
+        super().__init__(tokenizer)
+        self.plus_token = "<+>"
+        if self.plus_token not in self.tokenizer.vocab:
+            print(f"Warning: Token '{self.plus_token}' not found in GLM tokenizer vocabulary.")
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        modified_sequences = [self.plus_token + seq for seq in sequences]
+        tokenized = self.tokenizer(modified_sequences, **kwargs)
+        return tokenized
+
+
+class gLM2ForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.glm2 = AutoModel.from_pretrained(model_path, trust_remote_code=True)
+    
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = False,
+    ) -> torch.Tensor:
+        assert not output_attentions or not output_hidden_states, (
+            "output_attentions=True and output_hidden_states=True are not supported by gLM2ForEmbedding."
+        )
+
+        out = self.glm2(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+        )
+        return out.last_hidden_state
+
+
+def get_glm2_tokenizer(preset: str):
+    return GLMTokenizerWrapper(AutoTokenizer.from_pretrained(presets[preset], trust_remote_code=True))
+
+
+def build_glm2_model(preset: str) -> Tuple[gLM2ForEmbedding, AutoTokenizer]:
+    model_path = presets[preset]
+    model = gLM2ForEmbedding(model_path).eval()
+    tokenizer = get_glm2_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_glm2_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = AutoModel.from_pretrained(model_path, trust_remote_code=True).eval()
+    else:
+        if tokenwise:
+            model = AutoModelForTokenClassification.from_pretrained(
+                model_path, num_labels=num_labels, trust_remote_code=True
+            ).eval()
+        else:
+            model = AutoModelForSequenceClassification.from_pretrained(
+                model_path, num_labels=num_labels, trust_remote_code=True
+            ).eval()
+    tokenizer = get_glm2_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.glm
+    model, tokenizer = build_glm2_model('GLM2-650')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/protbert.py

@@ -0,0 +1,79 @@
+import torch
+import torch.nn as nn
+import re
+from typing import Optional, Union, List, Dict
+from transformers import BertModel, BertTokenizer, BertForSequenceClassification, BertForTokenClassification
+
+from .base_tokenizer import BaseSequenceTokenizer
+
+
+presets = {
+    'ProtBert': 'Rostlab/prot_bert',
+    'ProtBert-BFD': 'Rostlab/prot_bert_bfd',
+}
+
+
+class BERTTokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer: BertTokenizer):
+        super().__init__(tokenizer)
+        
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        sequences = [re.sub(r"[UZOB]", "X", seq) for seq in sequences]
+        sequences = [' '.join(seq) for seq in sequences]
+        tokenized = self.tokenizer(sequences, **kwargs)
+        return tokenized
+
+
+class ProtBertForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.plm = BertModel.from_pretrained(model_path, attn_implementation="sdpa")
+
+    def forward(
+            self,
+            input_ids: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if output_attentions:
+            out = self.plm(input_ids, attention_mask=attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.plm(input_ids, attention_mask=attention_mask).last_hidden_state
+
+
+def get_protbert_tokenizer(preset: str):
+    return BERTTokenizerWrapper(BertTokenizer.from_pretrained('Rostlab/prot_bert'))
+
+
+def build_protbert_model(preset: str):
+    model_path = presets[preset]
+    model = ProtBertForEmbedding(model_path).eval()
+    tokenizer = get_protbert_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_protbert_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = BertModel.from_pretrained(model_path).eval()
+    else:
+        if tokenwise:
+            model = BertForTokenClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+        else:
+            model = BertForSequenceClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+    tokenizer = get_protbert_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.protbert
+    model, tokenizer = build_protbert_model('ProtBert')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/proteinvec.py

@@ -0,0 +1,3 @@
+"""
+This is currently not supported
+"""

data/src/protify/base_models/prott5.py

@@ -0,0 +1,83 @@
+import torch
+import torch.nn as nn
+import re
+from typing import Optional, Union, List, Dict
+from transformers import T5EncoderModel, T5Tokenizer
+
+from .t5 import T5ForSequenceClassification, T5ForTokenClassification
+from .base_tokenizer import BaseSequenceTokenizer
+
+
+presets = {
+    'ProtT5': 'Rostlab/prot_t5_xl_half_uniref50-enc',
+    'ProtT5-XL-UniRef50-full-prec': 'Rostlab/prot_t5_xl_uniref50',
+    'ProtT5-XXL-UniRef50': 'Rostlab/prot_t5_xxl_uniref50',
+    'ProtT5-XL-BFD': 'Rostlab/prot_t5_xl_bfd',
+    'ProtT5-XXL-BFD': 'Rostlab/prot_t5_xxl_bfd',
+}
+
+
+class T5TokenizerWrapper(BaseSequenceTokenizer):
+    def __init__(self, tokenizer: T5Tokenizer):
+        super().__init__(tokenizer)
+
+    def __call__(self, sequences: Union[str, List[str]], **kwargs) -> Dict[str, torch.Tensor]:
+        if isinstance(sequences, str):
+            sequences = [sequences]
+        kwargs.setdefault('return_tensors', 'pt')
+        kwargs.setdefault('padding', 'longest')
+        kwargs.setdefault('add_special_tokens', True)
+        sequences = [re.sub(r"[UZOB]", "X", seq) for seq in sequences]
+        sequences = [' '.join(seq) for seq in sequences]
+        tokenized = self.tokenizer(sequences, **kwargs)
+        return tokenized
+
+
+class Prott5ForEmbedding(nn.Module):
+    def __init__(self, model_path: str):
+        super().__init__()
+        self.plm = T5EncoderModel.from_pretrained(model_path)
+
+    def forward(
+            self,
+            input_ids: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = None,
+    ) -> torch.Tensor:
+        if output_attentions:
+            out = self.plm(input_ids, attention_mask=attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.plm(input_ids, attention_mask=attention_mask).last_hidden_state
+
+
+def get_prott5_tokenizer(preset: str):
+    return T5TokenizerWrapper(T5Tokenizer.from_pretrained(presets[preset]))
+
+
+def build_prott5_model(preset: str):
+    model_path = presets[preset]
+    model = Prott5ForEmbedding(model_path).eval()
+    tokenizer = get_prott5_tokenizer(preset)
+    return model, tokenizer
+
+
+def get_prott5_for_training(preset: str, tokenwise: bool = False, num_labels: int = None, hybrid: bool = False):
+    model_path = presets[preset]
+    if hybrid:
+        model = T5EncoderModel.from_pretrained(model_path).eval()
+    else:
+        if tokenwise:
+            model = T5ForTokenClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+        else:
+            model = T5ForSequenceClassification.from_pretrained(model_path, num_labels=num_labels).eval()
+    tokenizer = get_prott5_tokenizer(preset)
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    # py -m src.protify.base_models.prott5
+    model, tokenizer = build_prott5_model('ProtT5')
+    print(model)
+    print(tokenizer)
+    print(tokenizer('MEKVQYLTRSAIRRASTIEMPQQARQKLQNLFINFCLILICBBOLLICIIVMLL'))

data/src/protify/base_models/random.py

@@ -0,0 +1,62 @@
+import torch
+import torch.nn as nn
+from typing import Optional
+from transformers import EsmTokenizer, EsmConfig
+from model_components.transformer import TransformerForMaskedLM, TransformerConfig
+
+
+presets = {
+    'Random': 'random',
+    'Random-Transformer': 'facebook/esm2_t12_35M_UR50D', # default is 35M version
+    'Random-ESM2-8': 'facebook/esm2_t6_8M_UR50D',
+    'Random-ESM2-35': 'facebook/esm2_t12_35M_UR50D',
+    'Random-ESM2-150': 'facebook/esm2_t30_150M_UR50D',
+    'Random-ESM2-650': 'facebook/esm2_t36_650M_UR50D',
+}
+
+
+class RandomModel(nn.Module):
+    def __init__(self, config: EsmConfig):
+        super().__init__()
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.holder_param = torch.nn.Parameter(torch.randn(1, 1, self.hidden_size))
+
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+        device = self.holder_param.device
+        return torch.randn(input_ids.shape[0], input_ids.shape[1], self.hidden_size, device=device)
+
+
+class RandomTransformer(nn.Module):
+    def __init__(self, config: TransformerConfig):
+        super().__init__()
+        self.config = config
+        self.transformer = TransformerForMaskedLM(config)
+
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, output_attentions: bool = False) -> torch.Tensor:
+        if output_attentions:
+            out = self.transformer(input_ids, attention_mask, output_attentions=output_attentions)
+            return out.last_hidden_state, out.attentions
+        else:
+            return self.transformer(input_ids, attention_mask).last_hidden_state
+
+
+def build_random_model(preset: str):
+    tokenizer = EsmTokenizer.from_pretrained('facebook/esm2_t12_35M_UR50D')
+    if preset == 'Random':
+        model = RandomModel(EsmConfig.from_pretrained('facebook/esm2_t12_35M_UR50D'))
+    else:
+        esm_config = EsmConfig.from_pretrained(presets[preset])
+        config = TransformerConfig()
+        config.hidden_size = esm_config.hidden_size
+        config.n_heads = esm_config.num_attention_heads
+        config.n_layers = esm_config.num_hidden_layers
+        config.vocab_size = esm_config.vocab_size
+        model = RandomTransformer(config).eval()
+    return model, tokenizer
+
+
+if __name__ == '__main__':
+    model, tokenizer = build_random_model('Random-Transformer')
+    print(model)
+    print(tokenizer)

data/src/protify/base_models/t5.py

@@ -0,0 +1,150 @@
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss, MSELoss, BCEWithLogitsLoss
+from typing import Optional, Tuple, Union
+from transformers.modeling_outputs import SequenceClassifierOutput, TokenClassifierOutput
+from transformers import T5EncoderModel, T5Config
+
+
+class T5ClassificationHead(nn.Module):
+    """Head for sentence-level classification tasks."""
+
+    def __init__(self, config: T5Config):
+        super().__init__()
+        self.dense = nn.Linear(config.d_model, config.d_model)
+        self.dropout = nn.Dropout(p=config.classifier_dropout)
+        self.out_proj = nn.Linear(config.d_model, config.num_labels)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.dense(hidden_states)
+        hidden_states = torch.tanh(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.out_proj(hidden_states)
+        return hidden_states
+
+
+class T5ForSequenceClassification(T5EncoderModel):
+    config_class = T5Config
+    def __init__(self, config: T5Config):
+        super().__init__(config)
+        self.classifier = T5ClassificationHead(config)
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> SequenceClassifierOutput:
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        encoder_outputs = self.encoder(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            head_mask=head_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = encoder_outputs[0]
+        cls_token = sequence_output[:, 0, :]
+
+        logits = self.classifier(cls_token)
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+            if self.config.problem_type is None:
+                if self.config.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.config.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.config.num_labels == 1:
+                    loss = loss_fct(logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        return SequenceClassifierOutput(
+            loss=loss,
+            logits=logits
+        )
+
+
+class T5ForTokenClassification(T5EncoderModel):
+    config_class = T5Config
+    def __init__(self, config: T5Config):
+        super().__init__(config)
+        self.classifier = T5ClassificationHead(config)
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> SequenceClassifierOutput:
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        encoder_outputs = self.encoder(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            head_mask=head_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = encoder_outputs[0]
+
+        logits = self.classifier(sequence_output)
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+            if self.config.problem_type is None:
+                if self.config.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.config.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.config.num_labels == 1:
+                    loss = loss_fct(logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        return TokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+        )
+    

data/src/protify/base_models/utils.py

@@ -0,0 +1,19 @@
+import torch.nn as nn
+from peft import LoraConfig, LoraModel
+
+
+def wrap_lora(module: nn.Module, r: int, lora_alpha: float, lora_dropout: float) -> nn.Module:
+    # these modules handle ESM++ and ESM2 attention types, as well as any additional transformer blocks from Syndev
+    target_modules=["layernorm_qkv.1", "out_proj", "query", "key", "value", "dense"]
+    lora_config = LoraConfig(
+        r=r,
+        lora_alpha=lora_alpha,
+        lora_dropout=lora_dropout,
+        bias="none",
+        target_modules=target_modules,
+    )
+    module = LoraModel(module, lora_config, 'default')
+    for name, param in module.named_parameters():
+        if 'classifier' in name.lower():
+            param.requires_grad = True
+    return module

data/src/protify/data/__init__.py

@@ -0,0 +1,15 @@
+from .supported_datasets import (
+    supported_datasets,
+    internal_datasets,
+    possible_with_vector_reps,
+    standard_data_benchmark,
+    testing,
+    residue_wise_problems
+)
+
+try:
+    from .dataset_descriptions import dataset_descriptions
+except ImportError:
+    dataset_descriptions = {}
+
+from .dataset_utils import list_supported_datasets, get_dataset_info 

data/src/protify/data/data_collators.py

@@ -0,0 +1,295 @@
+import torch
+from typing import List, Tuple, Dict, Union
+from .utils import pad_and_concatenate_dimer
+
+
+def _pad_matrix_embeds(embeds: List[torch.Tensor], max_len: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    # pad and concatenate, return padded embeds and mask
+    padded_embeds, attention_masks = [], []
+    for embed in embeds:
+        seq_len = embed.size(0)
+        padding_size = max_len - seq_len
+        
+        # Create attention mask (1 for real tokens, 0 for padding)
+        attention_mask = torch.ones(max_len, dtype=torch.long)
+        if padding_size > 0:
+            attention_mask[seq_len:] = 0
+            
+            # Pad along the sequence dimension (dim=0)
+            padding = torch.zeros((padding_size, embed.size(1)), dtype=embed.dtype)
+            padded_embed = torch.cat((embed, padding), dim=0)
+        else:
+            padded_embed = embed
+            
+        padded_embeds.append(padded_embed)
+        attention_masks.append(attention_mask)
+        
+    return torch.stack(padded_embeds), torch.stack(attention_masks)
+
+
+class StringCollator:
+    def __init__(self, tokenizer, **kwargs):
+        self.tokenizer = tokenizer
+
+    def __call__(self, batch: Tuple[List[str], List[str]]) -> Dict[str, torch.Tensor]:
+        batch = self.tokenizer(batch,
+                          padding='longest',
+                          return_tensors='pt',
+                          add_special_tokens=True)
+        return batch
+
+
+class StringLabelsCollator:
+    def __init__(self, tokenizer, task_type='tokenwise', **kwargs):
+        self.tokenizer = tokenizer
+        self.task_type = task_type
+
+    def __call__(self, batch: List[Tuple[str, Union[float, int]]]) -> Dict[str, torch.Tensor]:
+        seqs = [ex[0] for ex in batch]
+        labels = [ex[1] for ex in batch]
+
+        # Tokenize the sequences
+        batch_encoding = self.tokenizer(
+            seqs,
+            padding='longest',
+            truncation=False,
+            return_tensors='pt',
+            add_special_tokens=True
+        )
+        
+        # Handle labels based on tokenwise flag
+        if self.task_type == 'tokenwise':
+            # For token-wise labels, we need to pad to match the tokenized sequence length
+            attention_mask = batch_encoding['attention_mask']
+            lengths = [torch.sum(attention_mask[i]).item() for i in range(len(batch))]
+            max_length = max(lengths)
+
+            padded_labels = []
+            for label in labels:
+                if not isinstance(label, torch.Tensor):
+                    label = torch.tensor(label)
+
+                label = label.flatten()
+                padding_size = max_length - len(label)
+                # Pad or truncate labels to match tokenized sequence length
+                if padding_size > 0:
+                    # Pad with -100 (ignored by loss functions)
+                    padding = torch.full((padding_size,), -100, dtype=label.dtype)
+                    padded_label = torch.cat((label, padding))
+                else:
+                    padded_label = label[:max_length]
+                padded_labels.append(padded_label)
+            
+            # Stack all padded labels
+            batch_encoding['labels'] = torch.stack(padded_labels)
+        else:
+            # For sequence-level labels, just stack them
+            batch_encoding['labels'] = torch.stack([torch.tensor(ex[1]) for ex in batch])
+
+        if self.task_type == 'multilabel':
+            batch_encoding['labels'] = batch_encoding['labels'].float()
+        else:
+            batch_encoding['labels'] = batch_encoding['labels'].long()
+        
+        return batch_encoding
+
+
+class EmbedsLabelsCollator:
+    def __init__(self, full=False, task_type='tokenwise', **kwargs):
+        self.full = full
+        self.task_type = task_type
+        
+    def __call__(self, batch: List[Tuple[torch.Tensor, Union[float, int]]]) -> Dict[str, torch.Tensor]:
+        if self.full:
+            embeds = [ex[0] for ex in batch]
+            labels = [ex[1] for ex in batch]
+            
+            # Find max sequence length for padding
+            max_length = max(embed.size(0) for embed in embeds)
+            
+            embeds, attention_mask = _pad_matrix_embeds(embeds, max_length)
+            
+            # Pad labels
+            if self.task_type == 'tokenwise':
+                padded_labels = []
+                for label in labels:
+                    if not isinstance(label, torch.Tensor):
+                        label = torch.tensor(label)
+
+                    label = label.flatten()
+                    padding_size = max_length - len(label)
+                    if padding_size > 0:
+                        # Use -100 as padding value for labels (ignored by loss functions)
+                        padding = torch.full((padding_size,), -100, dtype=label.dtype)
+                        padded_label = torch.cat((label, padding))
+                    else:
+                        padded_label = label[:max_length]
+                    padded_labels.append(padded_label)
+            else:
+                padded_labels = labels
+            
+            labels = torch.stack(padded_labels)
+
+            if self.task_type == 'multilabel':
+                labels = labels.float()
+            else:
+                labels = labels.long()
+
+            return {
+                'embeddings': embeds,
+                'attention_mask': attention_mask,
+                'labels': labels,
+            }
+        else:
+            embeds = torch.stack([ex[0] for ex in batch])
+            labels = torch.stack([ex[1] for ex in batch])
+
+            if self.task_type == 'multilabel':
+                labels = labels.float()
+            else:
+                labels = labels.long()
+
+            return {
+                'embeddings': embeds,
+                'labels': labels
+            }
+
+
+class PairCollator_input_ids:
+    def __init__(self, tokenizer, **kwargs):
+        self.tokenizer = tokenizer
+
+    def __call__(self, batch: List[Tuple[str, str, Union[float, int]]]) -> Dict[str, torch.Tensor]:
+        seqs_a, seqs_b, labels = zip(*batch)
+        labels = torch.tensor(labels, dtype=torch.float)
+        tokenized = self.tokenizer(
+            seqs_a, seqs_b,
+            padding='longest',
+            return_tensors='pt'
+        )
+        return {
+            'input_ids': tokenized['input_ids'],
+            'attention_mask': tokenized['attention_mask'],
+            'labels': labels
+        }
+
+
+class PairCollator_ab:
+    def __init__(self, tokenizer, **kwargs):
+        self.tokenizer = tokenizer
+
+    def __call__(self, batch: List[Tuple[str, str, Union[float, int]]]) -> Dict[str, torch.Tensor]:
+        seqs_a, seqs_b, labels = zip(*batch)
+        labels = torch.tensor(labels, dtype=torch.float)
+        tokenized_a = self.tokenizer(
+            seqs_a,
+            padding='longest',
+            truncation=True,
+            return_tensors='pt'
+        )
+        tokenized_b = self.tokenizer(
+            seqs_b,
+            padding='longest',
+            truncation=True,
+            return_tensors='pt'
+        )
+        return {
+            'input_ids_a': tokenized_a['input_ids'],
+            'input_ids_b': tokenized_b['input_ids'],
+            'attention_mask_a': tokenized_a['attention_mask'],
+            'attention_mask_b': tokenized_b['attention_mask'],
+            'labels': labels
+        }
+
+
+class PairEmbedsLabelsCollator:
+    def __init__(self, full=False, **kwargs):
+        self.full = full
+        
+    def __call__(self, batch: List[Tuple[torch.Tensor, torch.Tensor, Union[float, int]]]) -> Dict[str, torch.Tensor]:
+        if self.full:
+            embeds_a = [ex[0] for ex in batch]
+            embeds_b = [ex[1] for ex in batch]
+            max_len_a = max(embed.size(0) for embed in embeds_a)
+            max_len_b = max(embed.size(0) for embed in embeds_b)
+            embeds_a, attention_mask_a = _pad_matrix_embeds(embeds_a, max_len_a)
+            embeds_b, attention_mask_b = _pad_matrix_embeds(embeds_b, max_len_b)
+            embeds, attention_mask = pad_and_concatenate_dimer(embeds_a, embeds_b, attention_mask_a, attention_mask_b)
+
+            labels = torch.stack([ex[2] for ex in batch])
+
+            return {
+                'embeddings': embeds,
+                'attention_mask': attention_mask,
+                'labels': labels
+            }
+        else:
+            embeds_a = torch.stack([ex[0] for ex in batch])
+            embeds_b = torch.stack([ex[1] for ex in batch]) 
+            labels = torch.stack([ex[2] for ex in batch])
+            embeds = torch.cat([embeds_a, embeds_b], dim=-1)
+            return {
+                'embeddings': embeds,
+                'labels': labels
+            }
+
+
+class OneHotCollator:
+    def __init__(self, alphabet="ACDEFGHIKLMNPQRSTVWY"):
+        # Add X for unknown amino acids, and special CLS and EOS tokens
+        alphabet = alphabet + "X"
+        alphabet = list(alphabet)
+        alphabet.append('cls')
+        alphabet.append('eos')
+        self.mapping = {token: idx for idx, token in enumerate(alphabet)}
+        
+    def __call__(self, batch):
+        seqs = [ex[0] for ex in batch]
+        labels = torch.stack([torch.tensor(ex[1]) for ex in batch])
+        
+        # Find the longest sequence in the batch (plus 2 for CLS and EOS)
+        max_len = max(len(seq) for seq in seqs) + 2
+        
+        # One-hot encode and pad each sequence
+        batch_size = len(seqs)
+        one_hot_tensors = []
+        attention_masks = []
+        
+        for seq in seqs:
+            seq = ['cls'] + list(seq) + ['eos']
+            # Create one-hot encoding for each sequence (including CLS and EOS)
+            seq_len = len(seq)
+            one_hot = torch.zeros(seq_len, len(self.alphabet))
+            
+            # Add sequence tokens in the middle
+            for pos, token in enumerate(seq):
+                if token in self.mapping:
+                    one_hot[pos, self.mapping[token]] = 1.0
+                else:
+                    # For non-canonical amino acids, use the X token
+                    one_hot[pos, self.mapping["X"]] = 1.0
+            
+            # Create attention mask (1 for actual tokens, 0 for padding)
+            attention_mask = torch.ones(seq_len)
+            
+            # Pad to the max length in this batch
+            padding_size = max_len - seq_len
+            if padding_size > 0:
+                padding = torch.zeros(padding_size, len(self.alphabet))
+                one_hot = torch.cat([one_hot, padding], dim=0)
+                # Add zeros to attention mask for padding
+                mask_padding = torch.zeros(padding_size)
+                attention_mask = torch.cat([attention_mask, mask_padding], dim=0)
+            
+            one_hot_tensors.append(one_hot)
+            attention_masks.append(attention_mask)
+        
+        # Stack all tensors in the batch
+        embeddings = torch.stack(one_hot_tensors)
+        attention_masks = torch.stack(attention_masks)
+        
+        return {
+            'embeddings': embeddings,
+            'attention_mask': attention_masks,
+            'labels': labels,
+        }

data/src/protify/data/data_mixin.py

@@ -0,0 +1,472 @@
+import torch
+import numpy as np
+import random
+import os
+import sqlite3
+from typing import List, Tuple, Dict, Optional
+from glob import glob
+from pandas import read_csv, read_excel
+from datasets import load_dataset, Dataset
+from dataclasses import dataclass
+from utils import print_message
+from .supported_datasets import supported_datasets, standard_data_benchmark
+
+
+AMINO_ACIDS = set('LAGVSERTIPDKQNFYMHWCXBUOZ* ')
+CODONS = set('aA@bB#$%rRnNdDcCeEqQ^G&ghHiIj+MmlJLkK(fFpPoO=szZwSXTtxWyYuvUV]}) ')
+DNA = set('ATCG ')
+RNA = set('AUCG ')
+
+
+@dataclass
+class DataArguments:
+    """
+    Args:
+    data_paths: List[str]
+        paths to the datasets
+    max_length: int
+        max length of sequences
+    trim: bool
+        whether to trim sequences to max_length
+    """
+    def __init__(
+            self,
+            data_names: List[str],
+            delimiter: str = ',',
+            col_names: List[str] = ['seqs', 'labels'],
+            max_length: int = 1024,
+            trim: bool = False,
+            data_dirs: Optional[List[str]] = [],
+            **kwargs
+        ):
+        self.data_names = data_names
+        self.data_dirs = data_dirs
+        self.delimiter = delimiter
+        self.col_names = col_names
+        self.max_length = max_length
+        self.trim = trim
+
+        if data_names[0] == 'standard_benchmark':
+            self.data_paths = [supported_datasets[data_name] for data_name in standard_data_benchmark]
+        else:
+            self.data_paths = []
+            for data_name in data_names:
+                if data_name in supported_datasets:
+                    self.data_paths.append(supported_datasets[data_name])
+                else:
+                    self.data_paths.append(data_name)
+        
+        if data_dirs is not None:
+            for dir in data_dirs:
+                if os.path.exists(dir):
+                    self.data_paths.append(dir)
+                else:
+                    raise FileNotFoundError(f'{dir} does not exist')
+
+
+class DataMixin:
+    def __init__(self, data_args: Optional[DataArguments] = None):
+        # intialize defaults
+        self._sql = False
+        self._full = False
+        self._max_length = 1024
+        self._trim = False
+        self._delimiter = ','
+        self._col_names = ['seqs', 'labels']
+        self.data_args = data_args
+
+    def _not_regression(self, labels): # not a great assumption but works most of the time
+        return all(isinstance(label, (int, float)) and label == int(label) for label in labels)
+
+    def _encode_labels(self, labels, tag2id):
+        return [torch.tensor([tag2id[tag] for tag in doc], dtype=torch.long) for doc in labels]
+
+    def _label_type_checker(self, labels):
+        ex = labels[0]
+        if self._not_regression(labels):
+            if isinstance(ex, list):
+                label_type = 'multilabel'
+            elif isinstance(ex, int) or isinstance(ex, float):
+                label_type = 'singlelabel' # binary or multiclass
+        elif isinstance(ex, str):
+            label_type = 'string'
+        else:
+            label_type = 'regression'
+        return label_type
+
+    def _select_from_sql(self, c, seq, cast_to_torch=True):
+        c.execute("SELECT embedding FROM embeddings WHERE sequence = ?", (seq,))
+        embedding = np.frombuffer(c.fetchone()[0], dtype=np.float32).reshape(1, -1)
+        if self._full:
+            embedding = embedding.reshape(len(seq), -1)
+        if cast_to_torch:
+            embedding = torch.tensor(embedding)
+        return embedding
+
+    def _select_from_pth(self, emb_dict, seq, cast_to_np=False):
+        embedding = emb_dict[seq].reshape(1, -1)
+        if self._full:
+            embedding = embedding.reshape(len(seq), -1)
+        if cast_to_np:
+            embedding = embedding.numpy()
+        return embedding
+
+    def _labels_to_numpy(self, labels):
+        if isinstance(labels[0], list):
+            return np.array(labels).flatten()
+        else:
+            return np.array([labels]).flatten()
+
+    def _random_order(self, seq_a, seq_b):
+        if random.random() < 0.5:
+            return seq_a, seq_b
+        else:
+            return seq_b, seq_a
+
+    def _truncate_pairs(self, ex):
+        # Truncate longest first, but if that makes it shorter than the other, truncate that one
+        seq_a, seq_b = ex['SeqA'], ex['SeqB']
+        trunc_a, trunc_b = seq_a, seq_b
+        while len(trunc_a) + len(trunc_b) > self._max_length:
+            if len(trunc_a) > len(trunc_b):
+                trunc_a = trunc_a[:-1]
+            else:
+                trunc_b = trunc_b[:-1]
+        ex['SeqA'] = trunc_a
+        ex['SeqB'] = trunc_b
+        return ex
+
+    def process_datasets(
+            self,
+            hf_datasets: List[Tuple[Dataset, Dataset, Dataset, bool]],
+            data_names: List[str],
+        )-> Tuple[Dict[str, Tuple[Dataset, Dataset, Dataset, int, str, bool]], List[str]]:
+        max_length = self._max_length
+        datasets, all_seqs = {}, set()
+        for dataset, data_name in zip(hf_datasets, data_names):
+            print_message(f'Processing {data_name}')
+            train_set, valid_set, test_set, ppi = dataset
+            if self._trim: # trim by length if necessary
+                original_train_size, original_valid_size, original_test_size = len(train_set), len(valid_set), len(test_set)
+                if ppi:
+                    train_set = train_set.filter(lambda x: len(x['SeqA']) + len(x['SeqB']) <= max_length)
+                    valid_set = valid_set.filter(lambda x: len(x['SeqA']) + len(x['SeqB']) <= max_length)
+                    test_set = test_set.filter(lambda x: len(x['SeqA']) + len(x['SeqB']) <= max_length)
+                else:
+                    train_set = train_set.filter(lambda x: len(x['seqs']) <= max_length)
+                    valid_set = valid_set.filter(lambda x: len(x['seqs']) <= max_length)
+                    test_set = test_set.filter(lambda x: len(x['seqs']) <= max_length)
+            
+                print_message(f'Trimmed {100 * round((original_train_size-len(train_set)) / original_train_size, 2)}% from train')
+                print_message(f'Trimmed {100 * round((original_valid_size-len(valid_set)) / original_valid_size, 2)}% from valid')
+                print_message(f'Trimmed {100 * round((original_test_size-len(test_set)) / original_test_size, 2)}% from test')
+
+            else: # truncate to max_length
+                if ppi:
+                    train_set = train_set.map(self._truncate_pairs)
+                    valid_set = valid_set.map(self._truncate_pairs)
+                    test_set = test_set.map(self._truncate_pairs)
+                else:
+                    train_set = train_set.map(lambda x: {'seqs': x['seqs'][:max_length]})
+                    valid_set = valid_set.map(lambda x: {'seqs': x['seqs'][:max_length]})
+                    test_set = test_set.map(lambda x: {'seqs': x['seqs'][:max_length]})
+
+            # sanitize
+            if ppi:
+                train_set = train_set.map(lambda x: {'SeqA': ''.join(aa for aa in x['SeqA'] if aa in AMINO_ACIDS),
+                                                     'SeqB': ''.join(aa for aa in x['SeqB'] if aa in AMINO_ACIDS)})
+                valid_set = valid_set.map(lambda x: {'SeqA': ''.join(aa for aa in x['SeqA'] if aa in AMINO_ACIDS),
+                                                     'SeqB': ''.join(aa for aa in x['SeqB'] if aa in AMINO_ACIDS)})
+                test_set = test_set.map(lambda x: {'SeqA': ''.join(aa for aa in x['SeqA'] if aa in AMINO_ACIDS),
+                                                   'SeqB': ''.join(aa for aa in x['SeqB'] if aa in AMINO_ACIDS)})
+                all_seqs.update(train_set['SeqA'] + train_set['SeqB'])
+                all_seqs.update(valid_set['SeqA'] + valid_set['SeqB'])
+                all_seqs.update(test_set['SeqA'] + test_set['SeqB'])
+            else:
+                train_set = train_set.map(lambda x: {'seqs': ''.join(aa for aa in x['seqs'] if aa in AMINO_ACIDS)})
+                valid_set = valid_set.map(lambda x: {'seqs': ''.join(aa for aa in x['seqs'] if aa in AMINO_ACIDS)})
+                test_set = test_set.map(lambda x: {'seqs': ''.join(aa for aa in x['seqs'] if aa in AMINO_ACIDS)})
+                all_seqs.update(train_set['seqs'])
+                all_seqs.update(valid_set['seqs'])
+                all_seqs.update(test_set['seqs'])
+                
+            # confirm the type of labels
+            check_labels = valid_set['labels']
+            label_type = self._label_type_checker(check_labels)
+
+            if label_type == 'string': # might be string or multilabel
+                example = valid_set['labels'][0]
+                try:
+                    import ast
+                    new_ex = ast.literal_eval(example)
+                    if isinstance(new_ex, list): # if ast runs correctly and is now a list it is multilabel labels
+                        label_type = 'multilabel'
+                        train_set = train_set.map(lambda ex: {'labels': ast.literal_eval(ex['labels'])})
+                        valid_set = valid_set.map(lambda ex: {'labels': ast.literal_eval(ex['labels'])})
+                        test_set = test_set.map(lambda ex: {'labels': ast.literal_eval(ex['labels'])})
+                except:
+                    label_type = 'string' # if ast throws error it is actually string
+
+            if label_type == 'string': # if still string, it's for tokenwise classification
+                train_labels = train_set['labels']
+                unique_tags = set(tag for doc in train_labels for tag in doc)
+                tag2id = {tag: id for id, tag in enumerate(sorted(unique_tags))}
+                # add cls token to labels
+                train_set = train_set.map(lambda ex: {'labels': self._encode_labels(ex['labels'], tag2id=tag2id)})
+                valid_set = valid_set.map(lambda ex: {'labels': self._encode_labels(ex['labels'], tag2id=tag2id)})
+                test_set = test_set.map(lambda ex: {'labels': self._encode_labels(ex['labels'], tag2id=tag2id)})
+                label_type = 'tokenwise'
+                num_labels = len(unique_tags)
+            else:
+                if label_type == 'regression':
+                    num_labels = 1
+                else: # if classification, get the total number of leabels
+                    try:
+                        num_labels = len(train_set['labels'][0])
+                    except:
+                        unique = np.unique(train_set['labels'])
+                        max_label = max(unique) # sometimes there are missing labels
+                        full_list = np.arange(0, max_label+1)
+                        num_labels = len(full_list)
+            datasets[data_name] = (train_set, valid_set, test_set, num_labels, label_type, ppi)
+
+        all_seqs = list(all_seqs)
+        all_seqs = sorted(all_seqs, key=len, reverse=True) # longest first
+        return datasets, all_seqs
+
+    def get_data(self):
+        """
+        Supports .csv, .tsv, .txt
+        TODO fasta, fa, fna, etc.
+        """
+        datasets, data_names = [], []
+
+        for data_path in self.data_args.data_paths:
+            data_name = data_path.split('/')[-1]
+            print_message(f'Loading {data_name}')
+            dataset = load_dataset(data_path)
+            ppi = 'SeqA' in dataset['train'].column_names
+            print_message(f'PPI: {ppi}')
+            try:
+                train_set, valid_set, test_set = dataset['train'], dataset['valid'], dataset['test']
+            except:
+                # No valid or test set, make 10% splits randomly
+                train_set = dataset['train'].train_test_split(test_size=0.2, seed=42)
+                valid_set = train_set['test']
+                train_set = train_set['train']
+                test_set = train_set.train_test_split(test_size=0.5, seed=42)
+                test_set = test_set['test']
+            datasets.append((train_set, valid_set, test_set, ppi))
+            data_names.append(data_name)
+
+        for data_dir in self.data_args.data_dirs:
+            data_name = data_dir.split('/')[-2]
+            ppi = 'ppi' in data_dir.lower()
+            train_path = glob(os.path.join(data_dir, 'train.*'))[0]
+            valid_path = glob(os.path.join(data_dir, 'valid.*'))[0]
+            test_path = glob(os.path.join(data_dir, 'test.*'))[0]
+            if '.xlsx' in train_path:
+                train_set = read_excel(train_path)
+                valid_set = read_excel(valid_path)
+                test_set = read_excel(test_path)
+            else:
+                train_set = read_csv(train_path, delimiter=self._delimiter, names=self._col_names)
+                valid_set = read_csv(valid_path, delimiter=self._delimiter, names=self._col_names)
+                test_set = read_csv(test_path, delimiter=self._delimiter, names=self._col_names)
+
+            train_set = Dataset.from_pandas(train_set)
+            valid_set = Dataset.from_pandas(valid_set)
+            test_set = Dataset.from_pandas(test_set)
+            datasets.append((train_set, valid_set, test_set, ppi))
+            data_names.append(data_name)
+
+        return self.process_datasets(hf_datasets=datasets, data_names=data_names)
+
+    def get_embedding_dim_sql(self, save_path, test_seq):
+        import sqlite3
+        test_seq_len = len(test_seq) + 2
+        
+        with sqlite3.connect(save_path) as conn:
+            c = conn.cursor()
+            c.execute("SELECT embedding FROM embeddings WHERE sequence = ?", (test_seq,))
+            test_embedding = c.fetchone()[0]
+            test_embedding = torch.tensor(np.frombuffer(test_embedding, dtype=np.float32).reshape(1, -1))
+        if self._full:
+            try:
+                test_embedding = test_embedding.reshape(test_seq_len, -1)
+            except:
+                test_embedding = test_embedding.reshape(test_seq_len - 1, -1) # some pLMs have only one special token added
+        embedding_dim = test_embedding.shape[-1]
+        return embedding_dim
+
+    def get_embedding_dim_pth(self, emb_dict, test_seq):
+        test_seq_len = len(test_seq) + 2
+
+        test_embedding = emb_dict[test_seq]
+        print(test_embedding.shape)
+        if self._full:
+            try:
+                test_embedding = test_embedding.reshape(test_seq_len, -1)
+            except:
+                test_embedding = test_embedding.reshape(test_seq_len - 1, -1) # some pLMs have only one special token added
+        else:
+            test_embedding = test_embedding.reshape(1, -1)
+        embedding_dim = test_embedding.shape[-1]
+        return embedding_dim
+
+    def build_vector_numpy_dataset_from_embeddings(
+            self,
+            model_name,
+            train_seqs,
+            valid_seqs,
+            test_seqs,
+        ):
+        save_dir = self.embedding_args.embedding_save_dir
+        train_array, valid_array, test_array = [], [], []
+        if self._sql:
+            import sqlite3
+            save_path = os.path.join(save_dir, f'{model_name}_{self._full}.db')
+            with sqlite3.connect(save_path) as conn:
+                c = conn.cursor()
+                for seq in train_seqs:
+                    embedding = self._select_from_sql(c, seq, cast_to_torch=False)
+                    train_array.append(embedding)
+
+                for seq in valid_seqs:
+                    embedding = self._select_from_sql(c, seq, cast_to_torch=False)
+                    valid_array.append(embedding)
+
+                for seq in test_seqs:
+                    embedding = self._select_from_sql(c, seq, cast_to_torch=False)
+                    test_array.append(embedding)
+        else:
+            save_path = os.path.join(save_dir, f'{model_name}_{self._full}.pth')
+            emb_dict = torch.load(save_path)
+            for seq in train_seqs:
+                embedding = self._select_from_pth(emb_dict, seq, cast_to_np=True)
+                train_array.append(embedding)
+                
+            for seq in valid_seqs:
+                embedding = self._select_from_pth(emb_dict, seq, cast_to_np=True)
+                valid_array.append(embedding)
+
+            for seq in test_seqs:
+                embedding = self._select_from_pth(emb_dict, seq, cast_to_np=True)
+                test_array.append(embedding)
+            del emb_dict
+
+        train_array = np.concatenate(train_array, axis=0)
+        valid_array = np.concatenate(valid_array, axis=0)
+        test_array = np.concatenate(test_array, axis=0)
+        
+        if self._full: # average over the length of the sequence
+            train_array = np.mean(train_array, axis=1)
+            valid_array = np.mean(valid_array, axis=1)
+            test_array = np.mean(test_array, axis=1)
+
+        print_message('Numpy dataset shapes')
+        print_message(f'Train: {train_array.shape}')
+        print_message(f'Valid: {valid_array.shape}')
+        print_message(f'Test: {test_array.shape}')
+        return train_array, valid_array, test_array
+
+    def build_pair_vector_numpy_dataset_from_embeddings(
+            self,
+            model_name,
+            train_seqs_a,
+            train_seqs_b,
+            valid_seqs_a,
+            valid_seqs_b,
+            test_seqs_a,
+            test_seqs_b,
+        ):
+        save_dir = self.embedding_args.embedding_save_dir
+        train_array, valid_array, test_array = [], [], []
+        if self._sql:
+            save_path = os.path.join(save_dir, f'{model_name}_{self._full}.db')
+            with sqlite3.connect(save_path) as conn:
+                c = conn.cursor()
+                for seq_a, seq_b in zip(train_seqs_a, train_seqs_b):
+                    seq_a, seq_b = self._random_order(seq_a, seq_b)
+                    embedding_a = self._select_from_sql(c, seq_a, cast_to_torch=False)
+                    embedding_b = self._select_from_sql(c, seq_b, cast_to_torch=False)
+                    train_array.append(np.concatenate([embedding_a, embedding_b], axis=-1))
+
+                for seq_a, seq_b in zip(valid_seqs_a, valid_seqs_b):
+                    seq_a, seq_b = self._random_order(seq_a, seq_b)
+                    embedding_a = self._select_from_sql(c, seq_a, cast_to_torch=False)
+                    embedding_b = self._select_from_sql(c, seq_b, cast_to_torch=False)
+                    valid_array.append(np.concatenate([embedding_a, embedding_b], axis=-1))
+
+                for seq_a, seq_b in zip(test_seqs_a, test_seqs_b):
+                    seq_a, seq_b = self._random_order(seq_a, seq_b)
+                    embedding_a = self._select_from_sql(c, seq_a, cast_to_torch=False)
+                    embedding_b = self._select_from_sql(c, seq_b, cast_to_torch=False)
+                    test_array.append(np.concatenate([embedding_a, embedding_b], axis=-1))
+        else:
+            save_path = os.path.join(save_dir, f'{model_name}_{self._full}.pth')
+            emb_dict = torch.load(save_path)
+            for seq_a, seq_b in zip(train_seqs_a, train_seqs_b):
+                seq_a, seq_b = self._random_order(seq_a, seq_b)
+                embedding_a = self._select_from_pth(emb_dict, seq_a, cast_to_np=True)
+                embedding_b = self._select_from_pth(emb_dict, seq_b, cast_to_np=True)
+                train_array.append(np.concatenate([embedding_a, embedding_b], axis=-1))
+
+            for seq_a, seq_b in zip(valid_seqs_a, valid_seqs_b):
+                seq_a, seq_b = self._random_order(seq_a, seq_b)
+                embedding_a = self._select_from_pth(emb_dict, seq_a, cast_to_np=True)
+                embedding_b = self._select_from_pth(emb_dict, seq_b, cast_to_np=True)
+                valid_array.append(np.concatenate([embedding_a, embedding_b], axis=-1))
+
+            for seq_a, seq_b in zip(test_seqs_a, test_seqs_b):
+                seq_a, seq_b = self._random_order(seq_a, seq_b)
+                embedding_a = self._select_from_pth(emb_dict, seq_a, cast_to_np=True)
+                embedding_b = self._select_from_pth(emb_dict, seq_b, cast_to_np=True)
+                test_array.append(np.concatenate([embedding_a, embedding_b], axis=-1))
+            del emb_dict
+
+        train_array = np.concatenate(train_array, axis=0)
+        valid_array = np.concatenate(valid_array, axis=0)
+        test_array = np.concatenate(test_array, axis=0)
+        
+        if self._full: # average over the length of the sequence
+            train_array = np.mean(train_array, axis=1)
+            valid_array = np.mean(valid_array, axis=1)
+            test_array = np.mean(test_array, axis=1)
+
+        print_message('Numpy dataset shapes')
+        print_message(f'Train: {train_array.shape}')
+        print_message(f'Valid: {valid_array.shape}')
+        print_message(f'Test: {test_array.shape}')
+        return train_array, valid_array, test_array
+
+    def prepare_scikit_dataset(self, model_name, dataset):
+        train_set, valid_set, test_set, _, label_type, ppi = dataset
+
+        if ppi:
+            X_train, X_valid, X_test = self.build_pair_vector_numpy_dataset_from_embeddings(
+                model_name,
+                train_set['SeqA'],
+                train_set['SeqB'],
+                valid_set['SeqA'],
+                valid_set['SeqB'],
+                test_set['SeqA'],
+                test_set['SeqB'],
+            )
+        else:
+            X_train, X_valid, X_test = self.build_vector_numpy_dataset_from_embeddings(
+                model_name,
+                train_set['seqs'],
+                valid_set['seqs'],
+                test_set['seqs'],
+            )
+
+        y_train = self._labels_to_numpy(train_set['labels'])
+        y_valid = self._labels_to_numpy(valid_set['labels'])
+        y_test = self._labels_to_numpy(test_set['labels'])
+
+        print_message('Numpy dataset shapes with labels')
+        print_message(f'Train: {X_train.shape}, {y_train.shape}')
+        print_message(f'Valid: {X_valid.shape}, {y_valid.shape}')
+        print_message(f'Test: {X_test.shape}, {y_test.shape}')
+        return X_train, y_train, X_valid, y_valid, X_test, y_test, label_type

data/src/protify/data/dataset_classes.py

@@ -0,0 +1,319 @@
+### imports
+import random
+import torch
+import numpy as np
+import sqlite3
+import torch.nn.functional as F
+from torch.utils.data import Dataset as TorchDataset
+from utils import print_message
+from tqdm.auto import tqdm
+
+
+class PairEmbedsLabelsDatasetFromDisk(TorchDataset):
+    def __init__(
+            self,
+            hf_dataset,
+            col_a='SeqA',
+            col_b='SeqB',
+            label_col='labels',
+            full=False, 
+            db_path='embeddings.db',
+            batch_size=64,
+            read_scaler=1000,
+            input_dim=768,
+            task_type='regression',
+            **kwargs
+        ):
+        self.seqs_a, self.seqs_b, self.labels = hf_dataset[col_a], hf_dataset[col_b], hf_dataset[label_col]
+        self.db_file = db_path
+        self.batch_size = batch_size
+        self.input_dim = input_dim
+        self.full = full
+        self.length = len(self.labels)
+        self.read_amt = read_scaler * self.batch_size
+        self.embeddings_a, self.embeddings_b, self.current_labels = [], [], []
+        self.count, self.index = 0, 0
+        self.task_type = task_type
+
+    def __len__(self):
+        return self.length
+
+    def check_seqs(self, all_seqs):
+        missing_seqs = [seq for seq in self.seqs_a + self.seqs_b if seq not in all_seqs]
+        if missing_seqs:
+            print_message(f'Sequences not found in embeddings: {missing_seqs}')
+        else:
+            print_message('All sequences in embeddings')
+
+    def reset_epoch(self):
+        data = list(zip(self.seqs_a, self.seqs_b, self.labels))
+        random.shuffle(data)
+        self.seqs_a, self.seqs_b, self.labels = zip(*data)
+        self.seqs_a, self.seqs_b, self.labels = list(self.seqs_a), list(self.seqs_b), list(self.labels)
+        self.embeddings_a, self.embeddings_b, self.current_labels = [], [], []
+        self.count, self.index = 0, 0
+
+    def get_embedding(self, c, seq):
+        result = c.execute("SELECT embedding FROM embeddings WHERE sequence=?", (seq,))
+        row = result.fetchone()
+        if row is None:
+            raise ValueError(f"Embedding not found for sequence: {seq}")
+        emb_data = row[0]
+        emb = torch.tensor(np.frombuffer(emb_data, dtype=np.float32).reshape(-1, self.input_dim))
+        return emb
+
+    def read_embeddings(self):
+        embeddings_a, embeddings_b, labels = [], [], []
+        self.count += self.read_amt
+        if self.count >= self.length:
+            self.reset_epoch()
+        conn = sqlite3.connect(self.db_file)
+        c = conn.cursor()
+        for i in range(self.count, self.count + self.read_amt):
+            if i >= self.length:
+                break
+            emb_a = self.get_embedding(c, self.seqs_a[i])
+            emb_b = self.get_embedding(c, self.seqs_b[i])
+            embeddings_a.append(emb_a)
+            embeddings_b.append(emb_b)
+            labels.append(self.labels[i])
+        conn.close()
+        self.index = 0
+        self.embeddings_a = embeddings_a
+        self.embeddings_b = embeddings_b
+        self.current_labels = labels
+
+    def __getitem__(self, idx):
+        if self.index >= len(self.current_labels) or len(self.current_labels) == 0:
+            self.read_embeddings()
+
+        emb_a = self.embeddings_a[self.index]
+        emb_b = self.embeddings_b[self.index]
+        label = self.current_labels[self.index]
+
+        self.index += 1
+
+        # 50% chance to switch the order of a and b
+        if random.random() < 0.5:
+            emb_a, emb_b = emb_b, emb_a
+
+        if self.task_type == 'multilabel' or self.task_type == 'regression':
+            label = torch.tensor(label, dtype=torch.float)
+        else:
+            label = torch.tensor(label, dtype=torch.long)
+
+        return emb_a, emb_b, label
+
+
+class PairEmbedsLabelsDataset(TorchDataset):
+    def __init__(
+            self,
+            hf_dataset,
+            emb_dict,
+            col_a='SeqA',
+            col_b='SeqB',
+            full=False,
+            label_col='labels',
+            input_dim=768,
+            task_type='regression',
+            **kwargs
+        ):
+        self.seqs_a = hf_dataset[col_a]
+        self.seqs_b = hf_dataset[col_b]
+        self.labels = hf_dataset[label_col]
+        self.input_dim = input_dim // 2 if not full else input_dim # already scaled if ppi
+        self.task_type = task_type
+        self.full = full
+
+        # Combine seqs_a and seqs_b to find all unique sequences needed
+        needed_seqs = set(hf_dataset[col_a] + hf_dataset[col_b])
+        # Filter emb_dict to keep only the necessary embeddings
+        self.emb_dict = {seq: emb_dict[seq] for seq in needed_seqs if seq in emb_dict}
+        # Check for any missing embeddings
+        missing_seqs = needed_seqs - self.emb_dict.keys()
+        if missing_seqs:
+            raise ValueError(f"Embeddings not found for sequences: {missing_seqs}")
+
+    def __len__(self):
+        return len(self.labels)
+        
+    def __getitem__(self, idx):
+        seq_a, seq_b = self.seqs_a[idx], self.seqs_b[idx]
+        emb_a = self.emb_dict.get(seq_a).reshape(-1, self.input_dim)
+        emb_b = self.emb_dict.get(seq_b).reshape(-1, self.input_dim)
+        
+        # 50% chance to switch the order of a and b
+        if random.random() < 0.5:
+            emb_a, emb_b = emb_b, emb_a
+
+        # Prepare the label
+        if self.task_type in ['multilabel', 'regression']:
+            label = torch.tensor(self.labels[idx], dtype=torch.float)
+        else:
+            label = torch.tensor(self.labels[idx], dtype=torch.long)
+
+        return emb_a, emb_b, label
+
+
+class EmbedsLabelsDatasetFromDisk(TorchDataset):
+    def __init__(
+            self,
+            hf_dataset,
+            col_name='seqs',
+            label_col='labels',
+            full=False,
+            db_path='embeddings.db',
+            batch_size=64,
+            read_scaler=1000,
+            input_dim=768,
+            task_type='singlelabel',
+            **kwargs
+        ): 
+        self.seqs, self.labels = hf_dataset[col_name], hf_dataset[label_col]
+        self.length = len(self.labels)
+        self.max_length = len(max(self.seqs, key=len))
+        print_message(f'Max length: {self.max_length}')
+
+        self.db_file = db_path
+        self.batch_size = batch_size
+        self.input_dim = input_dim
+        self.full = full
+
+        self.task_type = task_type
+        self.read_amt = read_scaler * self.batch_size
+        self.embeddings, self.current_labels = [], []
+        self.count, self.index = 0, 0
+
+        self.reset_epoch()
+
+    def __len__(self):
+        return self.length
+
+    def check_seqs(self, all_seqs):
+        cond = False
+        for seq in self.seqs:
+            if seq not in all_seqs:
+                cond = True
+            if cond:
+                break
+        if cond:
+            print_message('Sequences not found in embeddings')
+        else:
+            print_message('All sequences in embeddings')
+
+    def reset_epoch(self):
+        data = list(zip(self.seqs, self.labels))
+        random.shuffle(data)
+        self.seqs, self.labels = zip(*data)
+        self.seqs, self.labels = list(self.seqs), list(self.labels)
+        self.embeddings, self.current_labels = [], []
+        self.count, self.index = 0, 0
+
+    def read_embeddings(self):
+        embeddings, labels = [], []
+        self.count += self.read_amt
+        if self.count >= self.length:
+            self.reset_epoch()
+        conn = sqlite3.connect(self.db_file)
+        c = conn.cursor()
+        for i in range(self.count, self.count + self.read_amt):
+            if i >= self.length:
+                break
+            result = c.execute("SELECT embedding FROM embeddings WHERE sequence=?", (self.seqs[i],))
+            row = result.fetchone()
+            emb_data = row[0]
+            emb = torch.tensor(np.frombuffer(emb_data, dtype=np.float32).reshape(-1, self.input_dim))
+            if self.full:
+                padding_needed = self.max_length - emb.size(0)
+                emb = F.pad(emb, (0, 0, 0, padding_needed), value=0)
+            embeddings.append(emb)
+            labels.append(self.labels[i])
+        conn.close()
+        self.index = 0
+        self.embeddings = embeddings
+        self.current_labels = labels
+
+    def __getitem__(self, idx):
+        if self.index >= len(self.current_labels) or len(self.current_labels) == 0:
+            self.read_embeddings()
+
+        emb = self.embeddings[self.index]
+        label = self.current_labels[self.index]
+
+        self.index += 1
+
+        if self.task_type == 'multilabel' or self.task_type == 'regression':
+            label = torch.tensor(label, dtype=torch.float)
+        else:
+            label = torch.tensor(label, dtype=torch.long)
+
+        return emb.squeeze(0), label
+
+
+class EmbedsLabelsDataset(TorchDataset):
+    def __init__(self, hf_dataset, emb_dict, col_name='seqs', label_col='labels', task_type='singlelabel', full=False, **kwargs):
+        self.embeddings = self.get_embs(emb_dict, hf_dataset[col_name])
+        self.full = full
+        self.labels = hf_dataset[label_col]
+        self.task_type = task_type
+        self.max_length = len(max(hf_dataset[col_name], key=len))
+        print_message(f'Max length: {self.max_length}')
+
+    def __len__(self):
+        return len(self.labels)
+    
+    def get_embs(self, emb_dict, seqs):
+        embeddings = []
+        for seq in tqdm(seqs, desc='Loading Embeddings'):
+            emb = emb_dict[seq]
+            embeddings.append(emb)
+        return embeddings
+
+    def __getitem__(self, idx):
+        if self.task_type == 'multilabel' or self.task_type == 'regression':
+            label = torch.tensor(self.labels[idx], dtype=torch.float)
+        else:
+            label = torch.tensor(self.labels[idx], dtype=torch.long)
+        emb = self.embeddings[idx].float()
+        if self.full:
+            padding_needed = self.max_length - emb.size(0)
+            emb = F.pad(emb, (0, 0, 0, padding_needed), value=0)
+        return emb.squeeze(0), label
+    
+
+class StringLabelDataset(TorchDataset):    
+    def __init__(self, hf_dataset, col_name='seqs', label_col='labels', **kwargs):
+        self.seqs = hf_dataset[col_name]
+        self.labels = hf_dataset[label_col]
+        self.lengths = [len(seq) for seq in self.seqs]
+
+    def avg(self):
+        return sum(self.lengths) / len(self.lengths)
+
+    def __len__(self):
+        return len(self.seqs)
+    
+    def __getitem__(self, idx):
+        seq = self.seqs[idx]
+        label = self.labels[idx]
+        return seq, label
+    
+
+class PairStringLabelDataset(TorchDataset):
+    def __init__(self, hf_dataset, col_a='SeqA', col_b='SeqB', label_col='labels', train=True, **kwargs):
+        self.seqs_a, self.seqs_b = hf_dataset[col_a], hf_dataset[col_b]
+        self.labels = hf_dataset[label_col]
+        self.train = train
+
+    def avg(self):
+        return sum(len(seqa) + len(seqb) for seqa, seqb in zip(self.seqs_a, self.seqs_b)) / len(self.seqs_a)
+
+    def __len__(self):
+        return len(self.seqs_a)
+
+    def __getitem__(self, idx):
+        seq_a, seq_b = self.seqs_a[idx], self.seqs_b[idx]
+        if self.train and random.random() < 0.5:
+            seq_a, seq_b = seq_b, seq_a
+        return seq_a, seq_b, self.labels[idx]
+

data/src/protify/data/dataset_utils.py

@@ -0,0 +1,101 @@
+from .supported_datasets import (
+    supported_datasets,
+    internal_datasets,
+    possible_with_vector_reps,
+    standard_data_benchmark,
+    testing,
+    residue_wise_problems
+)
+
+def list_supported_datasets(with_descriptions=True):
+    """
+    Lists all supported datasets with optional descriptions.
+    
+    Args:
+        with_descriptions (bool): Whether to include descriptions (if available)
+    """
+    try:
+        from .dataset_descriptions import dataset_descriptions
+        has_descriptions = True
+    except ImportError:
+        has_descriptions = False
+        
+    if not with_descriptions or not has_descriptions:
+        print("\n=== Supported Datasets ===\n")
+        for dataset_name in supported_datasets:
+            print(f"- {dataset_name}: {supported_datasets[dataset_name]}")
+        return
+    
+    print("\n=== Supported Datasets ===\n")
+    
+    # Calculate maximum widths for formatting
+    max_name_len = max(len(name) for name in supported_datasets)
+    max_type_len = max(len(dataset_descriptions.get(name, {}).get('type', 'Unknown')) for name in supported_datasets if name in dataset_descriptions)
+    max_task_len = max(len(dataset_descriptions.get(name, {}).get('task', 'Unknown')) for name in supported_datasets if name in dataset_descriptions)
+    
+    # Print header
+    print(f"{'Dataset':<{max_name_len+2}}{'Type':<{max_type_len+2}}{'Task':<{max_task_len+2}}Description")
+    print("-" * (max_name_len + max_type_len + max_task_len + 50))
+    
+    # Print dataset information
+    for dataset_name in supported_datasets:
+        if dataset_name in dataset_descriptions:
+            dataset_info = dataset_descriptions[dataset_name]
+            print(f"{dataset_name:<{max_name_len+2}}{dataset_info.get('type', 'Unknown'):<{max_type_len+2}}{dataset_info.get('task', 'Unknown'):<{max_task_len+2}}{dataset_info.get('description', 'No description available')}")
+        else:
+            print(f"{dataset_name:<{max_name_len+2}}{'Unknown':<{max_type_len+2}}{'Unknown':<{max_task_len+2}}No description available")
+    
+    print("\n=== Standard Benchmark Datasets ===\n")
+    for dataset_name in standard_data_benchmark:
+        print(f"- {dataset_name}")
+    
+    print("\n=== Residue-wise Datasets ===\n")
+    for dataset_name in residue_wise_problems:
+        print(f"- {dataset_name}")
+
+def get_dataset_info(dataset_name):
+    """
+    Get detailed information about a specific dataset.
+    
+    Args:
+        dataset_name (str): Name of the dataset
+        
+    Returns:
+        dict: Dataset information or None if not found
+    """
+    try:
+        from .dataset_descriptions import dataset_descriptions
+        if dataset_name in dataset_descriptions:
+            return dataset_descriptions[dataset_name]
+    except ImportError:
+        pass
+        
+    if dataset_name in supported_datasets:
+        return {"name": dataset_name, "source": supported_datasets[dataset_name]}
+    
+    return None
+
+if __name__ == "__main__":
+    import sys
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='List and describe supported datasets')
+    parser.add_argument('--list', action='store_true', help='List all supported datasets')
+    parser.add_argument('--info', type=str, help='Get information about a specific dataset')
+    args = parser.parse_args()
+    
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)
+        
+    if args.list:
+        list_supported_datasets()
+        
+    if args.info:
+        dataset_info = get_dataset_info(args.info)
+        if dataset_info:
+            print(f"\n=== Dataset: {args.info} ===\n")
+            for key, value in dataset_info.items():
+                print(f"{key.capitalize()}: {value}")
+        else:
+            print(f"Dataset '{args.info}' not found in supported datasets.") 

data/src/protify/data/supported_datasets.py

@@ -0,0 +1,99 @@
+
+supported_datasets = {
+    'EC': 'GleghornLab/EC_reg',
+    'GO-CC': 'GleghornLab/CC_reg',
+    'GO-BP': 'GleghornLab/BP_reg',
+    'GO-MF': 'GleghornLab/MF_reg',
+    'MB': 'GleghornLab/MB_reg',
+    'DeepLoc-2': 'GleghornLab/DL2_reg',
+    'DeepLoc-10': 'GleghornLab/DL10_reg',
+    'enzyme-kcat': 'GleghornLab/enzyme_kcat',
+    'solubility': 'GleghornLab/solubility_prediction',
+    'localization': 'GleghornLab/localization_prediction',
+    'temperature-stability': 'GleghornLab/temperature_stability',
+    'peptide-HLA-MHC-affinity': 'GleghornLab/peptide_HLA_MHC_affinity_ppi',
+    'optimal-temperature': 'GleghornLab/optimal_temperature',
+    'optimal-ph': 'GleghornLab/optimal_ph',
+    'material-production': 'GleghornLab/material_production',
+    'fitness-prediction': 'GleghornLab/fitness_prediction',
+    'number-of-folds': 'GleghornLab/fold_prediction',
+    'cloning-clf': 'GleghornLab/cloning_clf',
+    'stability-prediction': 'GleghornLab/stability_prediction',
+    'human-ppi': 'GleghornLab/HPPI',
+    'SecondaryStructure-3': 'GleghornLab/SS3',
+    'SecondaryStructure-8': 'GleghornLab/SS8',
+    'fluorescence-prediction': 'GleghornLab/fluorescence_prediction',
+    'plastic': 'GleghornLab/plastic_degradation_benchmark',
+    'gold-ppi': 'Synthyra/bernett_gold_ppi',
+    'human-ppi-pinui': 'GleghornLab/HPPI_PiNUI',
+    'yeast-ppi-pinui': 'GleghornLab/YPPI_PiNUI',
+    'shs27-ppi': 'Synthyra/SHS27k',
+    'shs148-ppi': 'Synthyra/SHS148k',
+    'PPA-ppi': 'Synthyra/ProteinProteinAffinity',
+    'synthyra-ppi': 'Synthyra/ppi_set_v5',
+}
+
+internal_datasets = {
+    'synthyra-ppi': 'Synthyra/ppi_set_v5',
+    'plastic': 'GleghornLab/plastic_degradation_benchmark',
+}
+
+possible_with_vector_reps = [
+    # multi-label
+    'EC',
+    'GO-CC',
+    'GO-BP',
+    'GO-MF',
+    # classification
+    'MB',
+    'DeepLoc-2',
+    'DeepLoc-10',
+    'solubility',
+    'localization',
+    'temperature-stability',
+    'material-production',
+    'fitness-prediction',
+    'number-of-folds',
+    'cloning-clf',
+    'stability-prediction',
+    # regression
+    'enzyme-kcat',
+    'optimal-temperature',
+    'optimal-ph',
+    # ppi
+    'human-ppi',
+    'PPA-ppi',
+    'human-ppi-pinui',
+    'yeast-ppi-pinui',
+    'gold-ppi',
+    'peptide-HLA-MHC-affinity',
+]
+
+standard_data_benchmark = [
+    'EC',
+    'GO-CC',
+    'GO-BP',
+    'GO-MF',
+    'MB',
+    'DeepLoc-2',
+    'DeepLoc-10',
+    'enzyme-kcat',
+    'optimal-temperature',
+    'optimal-ph',
+    'fitness-prediction',
+]
+
+testing = [
+    'EC', # multilabel
+    'DeepLoc-2', # 
+    'DeepLoc-10', # multiclass
+    'enzyme-kcat', # regression
+    'human-ppi', # ppi
+]
+
+
+residue_wise_problems = [
+    'SecondaryStructure-3',
+    'SecondaryStructure-8',
+    'fluorescence-prediction',
+]

data/src/protify/data/utils.py

@@ -0,0 +1,31 @@
+import torch
+from typing import Optional, Tuple
+
+
+def pad_and_concatenate_dimer(
+        A: torch.Tensor,
+        B: torch.Tensor,
+        a_mask: Optional[torch.Tensor] = None,
+        b_mask: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Given two sequences A and B with masks, pad (if needed) and concatenate them.
+    """
+    batch_size, L, d = A.size()
+    if a_mask is None:
+        a_mask = torch.ones(batch_size, L, device=A.device)
+    if b_mask is None:
+        b_mask = torch.ones(batch_size, L, device=A.device)
+    # Compute the maximum (valid) length in the batch.
+    max_len = max(
+        int(a_mask[i].sum().item() + b_mask[i].sum().item())
+        for i in range(batch_size)
+    )
+    combined = torch.zeros(batch_size, max_len, d, device=A.device)
+    combined_mask = torch.zeros(batch_size, max_len, device=A.device)
+    for i in range(batch_size):
+        a_len = int(a_mask[i].sum().item())
+        b_len = int(b_mask[i].sum().item())
+        combined[i, :a_len] = A[i, :a_len]
+        combined[i, a_len:a_len+b_len] = B[i, :b_len]
+        combined_mask[i, :a_len+b_len] = 1
+    return combined, combined_mask

data/src/protify/embedder.py

@@ -0,0 +1,426 @@
+import os
+import torch
+import warnings
+import sqlite3
+import gzip
+from torch.utils.data import Dataset, DataLoader
+from tqdm.auto import tqdm
+from dataclasses import dataclass
+from typing import Optional, Callable, List, Tuple
+from huggingface_hub import hf_hub_download
+from base_models.get_base_models import get_base_model
+from utils import torch_load, print_message
+
+
+@dataclass
+class EmbeddingArguments:
+    def __init__(
+            self,
+            embedding_batch_size: int = 4,
+            embedding_num_workers: int = 0,
+            download_embeddings: bool = False,
+            download_dir: str = 'Synthyra/mean_pooled_embeddings',
+            matrix_embed: bool = False,
+            embedding_pooling_types: List[str] = ['mean'],
+            save_embeddings: bool = False,
+            embed_dtype: torch.dtype = torch.float32,
+            sql: bool = False,
+            embedding_save_dir: str = 'embeddings',
+            **kwargs
+    ):
+        self.batch_size = embedding_batch_size
+        self.num_workers = embedding_num_workers
+        self.download_embeddings = download_embeddings
+        self.download_dir = download_dir
+        self.matrix_embed = matrix_embed
+        self.pooling_types = embedding_pooling_types
+        self.save_embeddings = save_embeddings
+        self.embed_dtype = embed_dtype
+        self.sql = sql
+        self.embedding_save_dir = embedding_save_dir
+
+
+class Pooler:
+    def __init__(self, pooling_types: List[str]):
+        self.pooling_types = pooling_types
+        self.pooling_options = {
+            'mean': self.mean_pooling,
+            'max': self.max_pooling,
+            'norm': self.norm_pooling,
+            'median': self.median_pooling,
+            'std': self.std_pooling,
+            'var': self.var_pooling,
+            'cls': self.cls_pooling,
+        }
+
+    def mean_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        if attention_mask is None:
+            return emb.mean(dim=1)
+        else:
+            attention_mask = attention_mask.unsqueeze(-1)
+            return (emb * attention_mask).sum(dim=1) / attention_mask.sum(dim=1)
+
+    def max_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        if attention_mask is None:
+            return emb.max(dim=1).values
+        else:
+            attention_mask = attention_mask.unsqueeze(-1)
+            return (emb * attention_mask).max(dim=1).values
+
+    def norm_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        if attention_mask is None:
+            return emb.norm(dim=1, p=2)
+        else:
+            attention_mask = attention_mask.unsqueeze(-1)
+            return (emb * attention_mask).norm(dim=1, p=2)
+
+    def median_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        if attention_mask is None:
+            return emb.median(dim=1).values
+        else:
+            attention_mask = attention_mask.unsqueeze(-1)
+            return (emb * attention_mask).median(dim=1).values
+    
+    def std_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        if attention_mask is None:
+            return emb.std(dim=1)
+        else:
+            attention_mask = attention_mask.unsqueeze(-1)
+            return (emb * attention_mask).std(dim=1)
+    
+    def var_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        if attention_mask is None:
+            return emb.var(dim=1)
+        else:
+            attention_mask = attention_mask.unsqueeze(-1)
+            return (emb * attention_mask).var(dim=1)
+
+    def cls_pooling(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # (b, L, d) -> (b, d)
+        return emb[:, 0, :]
+
+    def __call__(self, emb: torch.Tensor, attention_mask: Optional[torch.Tensor] = None): # [mean, max]
+        final_emb = []
+        for pooling_type in self.pooling_types:
+            final_emb.append(self.pooling_options[pooling_type](emb, attention_mask)) # (b, d)
+        return torch.cat(final_emb, dim=-1) # (b, n_pooling_types * d)
+
+
+def pool_parti(X: torch.Tensor, attentions: Tuple[torch.Tensor], attention_mask: torch.Tensor) -> torch.Tensor:
+    # X: (bs, seq_len, d)
+    # attentions: num_layres of (bs, n_heads, seq_len, seq_len)
+    # attention_mask: (bs, seq_len)
+    bs, seq_len, _ = X.shape
+    attentions = torch.stack(attentions, dim=1).float() # (bs, n_layers, n_heads, seq_len, seq_len)
+    att_mask = attention_mask[:, None, None, None, :].expand(bs, 1, 1, seq_len, seq_len)
+    attentions = attentions * att_mask
+    attentions = attentions.mean(dim=2) # (bs, n_layers, seq_len, seq_len)
+    attentions = attentions.mean(dim=1) # (bs, seq_len, seq_len)
+    attentions = attentions.mean(dim=-1) # (bs, seq_len)
+    X = X * attentions.unsqueeze(-1)
+    attention_mask = attention_mask.unsqueeze(-1)
+    return (X * attention_mask).sum(dim=1) / attention_mask.sum(dim=1) # (bs, d)
+
+
+### Dataset for Embedding
+class ProteinDataset(Dataset):
+    """Simple dataset for protein sequences."""
+    def __init__(self, sequences: List[str]):
+        self.sequences = sequences
+
+    def __len__(self) -> int:
+        return len(self.sequences)
+
+    def __getitem__(self, idx: int) -> str:
+        return self.sequences[idx]
+
+
+def build_collator(tokenizer) -> Callable[[List[str]], tuple[torch.Tensor, torch.Tensor]]:
+    def _collate_fn(sequences: List[str]) -> tuple[torch.Tensor, torch.Tensor]:
+        """Collate function for batching sequences."""
+        return tokenizer(sequences, return_tensors="pt", padding='longest', pad_to_multiple_of=8)
+    return _collate_fn
+
+
+class Embedder:
+    def __init__(self, args: EmbeddingArguments, all_seqs: List[str]):
+        self.args = args
+        self.all_seqs = all_seqs
+        self.batch_size = args.batch_size
+        self.num_workers = args.num_workers
+        self.matrix_embed = args.matrix_embed
+        self.pooling_types = args.pooling_types
+        self.download_embeddings = args.download_embeddings
+        self.download_dir = args.download_dir
+        self.save_embeddings = args.save_embeddings
+        self.embed_dtype = args.embed_dtype
+        self.sql = args.sql
+        self.embedding_save_dir = args.embedding_save_dir
+
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print_message(f'Device {self.device} found')
+
+    def _download_embeddings(self, model_name: str):
+        # download from download_dir
+        # unzip
+        # move to embedding_save_dir
+        try:
+            local_path = hf_hub_download(
+                repo_id=self.download_dir,
+                filename=f'embeddings/{model_name}_{self.matrix_embed}.pth.gz',
+                repo_type='dataset'
+            )
+        except:
+            print(f'No embeddings found for {model_name} in {self.download_dir}')
+            return
+
+        # unzip
+        print_message(f'Unzipping {local_path}')
+        with gzip.open(local_path, 'rb') as f_in:
+            with open(local_path.replace('.gz', ''), 'wb') as f_out:
+                f_out.write(f_in.read())
+        # move to embedding_save_dir
+        unzipped_path = local_path.replace('.gz', '')
+        final_path = os.path.join(self.embedding_save_dir, f'{model_name}_{self.matrix_embed}.pth')
+        
+        if os.path.exists(final_path):
+            print_message(f'Found existing embeddings in {final_path}')
+            # Load downloaded embeddings
+            downloaded_embeddings = torch_load(unzipped_path)
+            existing_embeddings = torch_load(final_path)
+
+            download_dtype = torch.float16
+            if self.embed_dtype != download_dtype:
+                print_message(f"Warning:\nDownloaded embeddings are {download_dtype} but the current setting is {self.embed_dtype}\nWhen combining with existing embeddings, this could result in unintended biases or reductions in performance")
+
+            # Combine with existing embeddings
+            print_message('Combining and casting')
+            downloaded_embeddings.update(existing_embeddings)
+
+            # Cast all embeddings to the correct dtype
+            for seq in downloaded_embeddings:
+                downloaded_embeddings[seq] = downloaded_embeddings[seq].to(self.embed_dtype)
+
+            # Save the combined embeddings
+            print_message(f'Saving combined embeddings to {final_path}')
+            torch.save(downloaded_embeddings, final_path)
+        else:
+            print_message(f'Downloading embeddings from {self.download_dir}, no previous embeddings found')
+            downloaded_embeddings = torch.load(unzipped_path)
+            torch.save(downloaded_embeddings, final_path)
+        return final_path
+
+    def _read_sequences_from_db(self, db_path: str) -> set[str]:
+        """Read sequences from SQLite database."""
+        import sqlite3
+        sequences = []
+        with sqlite3.connect(db_path) as conn:
+            c = conn.cursor()
+            c.execute("SELECT sequence FROM embeddings")
+            while True:
+                row = c.fetchone()
+                if row is None:
+                    break
+                sequences.append(row[0])
+        return set(sequences)
+
+    def _read_embeddings_from_disk(self, model_name: str):
+        if self.sql:
+            save_path = os.path.join(self.embedding_save_dir, f'{model_name}_{self.matrix_embed}.db')
+            if os.path.exists(save_path):
+                conn = sqlite3.connect(save_path)
+                c = conn.cursor()
+                c.execute('CREATE TABLE IF NOT EXISTS embeddings (sequence text PRIMARY KEY, embedding blob)')
+                already_embedded = self._read_sequences_from_db(save_path)
+                to_embed = [seq for seq in self.all_seqs if seq not in already_embedded]
+                print_message(f"Loaded {len(already_embedded)} already embedded sequences from {save_path}\nEmbedding {len(to_embed)} new sequences")
+                return to_embed, save_path, {}
+            else:
+                print_message(f"No embeddings found in {save_path}")
+                return self.all_seqs, save_path, {}
+
+        else:
+            embeddings_dict = {}
+            save_path = os.path.join(self.embedding_save_dir, f'{model_name}_{self.matrix_embed}.pth')
+            if os.path.exists(save_path):
+                print_message(f"Loading embeddings from {save_path}")
+                embeddings_dict = torch_load(save_path)
+                print_message(f"Loaded {len(embeddings_dict)} embeddings from {save_path}")
+                # Cast existing embeddings to the specified dtype
+                #for seq in embeddings_dict:
+                #    embeddings_dict[seq] = embeddings_dict[seq].to(self.embed_dtype)
+                to_embed = [seq for seq in self.all_seqs if seq not in embeddings_dict]
+                return to_embed, save_path, embeddings_dict
+            else:
+                print_message(f"No embeddings found in {save_path}")
+                return self.all_seqs, save_path, {}
+
+    def _embed_sequences(
+            self,
+            to_embed: List[str],
+            save_path: str,
+            embedding_model: any,
+            tokenizer: any,
+            embeddings_dict: dict[str, torch.Tensor]) -> Optional[dict[str, torch.Tensor]]:
+        os.makedirs(self.embedding_save_dir, exist_ok=True)
+        model = embedding_model.to(self.device).eval()
+        torch.compile(model)
+        device = self.device
+        collate_fn = build_collator(tokenizer)
+        print_message(f'Pooling types: {self.pooling_types}')
+        if self.pooling_types[0] == 'parti':
+            pooler = pool_parti
+        elif not self.matrix_embed:
+            pooler = Pooler(self.pooling_types)
+        else:
+            pooler = None
+
+        def _get_embeddings(residue_embeddings: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+            if residue_embeddings.ndim == 2 or self.matrix_embed: # sometimes already vector emb
+                return residue_embeddings
+            else:
+                return pooler(residue_embeddings, attention_mask)
+
+        dataset = ProteinDataset(to_embed)
+        dataloader = DataLoader(dataset, batch_size=self.batch_size, num_workers=self.num_workers, collate_fn=collate_fn, shuffle=False)
+
+        if self.sql:
+            conn = sqlite3.connect(save_path)
+            c = conn.cursor()
+            c.execute('CREATE TABLE IF NOT EXISTS embeddings (sequence text PRIMARY KEY, embedding blob)')
+
+        with torch.no_grad():
+            for i, batch in tqdm(enumerate(dataloader), total=len(dataloader), desc='Embedding batches'):
+                seqs = to_embed[i * self.batch_size:(i + 1) * self.batch_size]
+                input_ids, attention_mask = batch['input_ids'].to(device), batch['attention_mask'].to(device)
+                if self.pooling_types[0] == 'parti':
+                    try:
+                        residue_embeddings, attentions = model(input_ids, attention_mask, output_attentions=True)
+                        embeddings = pooler(residue_embeddings, attentions, attention_mask).cpu()
+                    except Exception as e:
+                        print_message(f"Error in parti pooling: {e}\nDefaulting to mean pooling")
+                        self.pooling_types = ['mean']
+                        pooler = Pooler(self.pooling_types)
+                        residue_embeddings = model(input_ids, attention_mask)
+                        embeddings = pooler(residue_embeddings, attention_mask).cpu()
+                else:
+                    residue_embeddings = model(input_ids, attention_mask)
+                    embeddings = _get_embeddings(residue_embeddings, attention_mask).cpu()
+
+                for seq, emb, mask in zip(seqs, embeddings, attention_mask.cpu()):
+                    if self.matrix_embed:
+                        emb = emb[mask.bool()]
+                    
+                    if self.sql:
+                        c.execute("INSERT OR REPLACE INTO embeddings VALUES (?, ?)", 
+                                (seq, emb.numpy().tobytes())) # only supports float32
+                    else:
+                        embeddings_dict[seq] = emb.to(self.embed_dtype)
+                
+                if (i + 1) % 100 == 0 and self.sql:
+                    conn.commit()
+
+        if self.sql:
+            conn.commit()
+            conn.close()
+            return None
+        
+        if self.save_embeddings:
+            print_message(f"Saving embeddings to {save_path}")
+            torch.save(embeddings_dict, save_path)
+            
+        return embeddings_dict
+
+    def __call__(self, model_name: str):
+        if self.download_embeddings:
+            self._download_embeddings(model_name)
+
+        if self.device == 'cpu':
+            warnings.warn("Downloading embeddings is recommended for CPU usage - Embedding on CPU will be extremely slow!")
+        to_embed, save_path, embeddings_dict = self._read_embeddings_from_disk(model_name)
+        
+        if len(to_embed) > 0:
+            print_message(f"Embedding {len(to_embed)} sequences with {model_name}")
+            model, tokenizer = get_base_model(model_name)
+            return self._embed_sequences(to_embed, save_path, model, tokenizer, embeddings_dict)
+        else:
+            print_message(f"No sequences to embed with {model_name}")
+            return None
+
+
+if __name__ == '__main__':
+    ### Embed all supported datasets with all supported models
+    # py -m embedder
+    import argparse
+    from huggingface_hub import upload_file, login
+    from data.supported_datasets import possible_with_vector_reps
+    from data.data_mixin import DataArguments, DataMixin
+    from base_models.get_base_models import BaseModelArguments, get_base_model
+
+    os.environ['HF_HUB_DISABLE_SYMLINKS_WARNING'] = '1' # prevent cache warning on Windows machines
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--token', default=None, help='Huggingface token')
+    parser.add_argument('--batch_size', type=int, default=4)
+    parser.add_argument('--num_workers', type=int, default=0)
+    parser.add_argument('--embed_dtype', type=str, default='float16')
+    parser.add_argument('--embedding_save_dir', type=str, default='embeddings')
+    parser.add_argument('--download_dir', type=str, default='Synthyra/mean_pooled_embeddings')
+    args = parser.parse_args()
+
+    if args.token is not None:
+        login(args.token)
+
+    if args.embed_dtype == 'float16':
+        dtype = torch.float16
+    elif args.embed_dtype == 'bfloat16':
+        dtype = torch.bfloat16
+    elif args.embed_dtype == 'float32':
+        dtype = torch.float32
+    else:
+        raise ValueError(f"Invalid embedding dtype: {args.embed_dtype}")
+
+    # Get data    
+    data_args = DataArguments(
+        data_names=possible_with_vector_reps,
+        max_length=1024,
+        trim=False
+    )
+    all_seqs = DataMixin(data_args).get_data()[1]
+
+    # Set up embedder
+    embedder_args = EmbeddingArguments(
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        download_embeddings=True,
+        matrix_embed=False,
+        pooling_types=['mean'],
+        save_embeddings=True,
+        embed_dtype=dtype,
+        sql=False,
+        embedding_save_dir='embeddings'
+    )
+    embedder = Embedder(embedder_args, all_seqs)
+
+    # Embed for each model
+    model_args = BaseModelArguments(model_names=['standard'])
+    for model_name in model_args.model_names:
+        _ = embedder(model_name)
+        save_path = os.path.join(args.embedding_save_dir, f'{model_name}_False.pth')
+        
+        compressed_path = f"{save_path}.gz"
+        print(f"Compressing {save_path} to {compressed_path}")
+        with open(save_path, 'rb') as f_in:
+            with gzip.open(compressed_path, 'wb') as f_out:
+                f_out.write(f_in.read())
+        upload_path = compressed_path
+        path_in_repo = f'embeddings/{model_name}_False.pth.gz'
+
+            
+        upload_file(
+            path_or_fileobj=upload_path,
+            path_in_repo=path_in_repo,
+            repo_id=args.download_dir,
+            repo_type='dataset'
+        )
+
+    print('Done')

data/src/protify/gui.py

@@ -0,0 +1,1046 @@
+import torch
+import tkinter as tk
+import argparse
+import queue
+import traceback
+import webbrowser
+import os
+from types import SimpleNamespace
+from tkinter import ttk, messagebox, filedialog
+from base_models.get_base_models import BaseModelArguments, standard_models
+from data.supported_datasets import supported_datasets, standard_data_benchmark, internal_datasets
+from embedder import EmbeddingArguments
+from probes.get_probe import ProbeArguments
+from probes.trainers import TrainerArguments
+from main import MainProcess
+from concurrent.futures import ThreadPoolExecutor
+from data.data_mixin import DataArguments
+from probes.scikit_classes import ScikitArguments
+from utils import print_message, print_done, print_title
+from visualization.plot_result import create_plots
+
+
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+
+
+class BackgroundTask:
+    def __init__(self, target, *args, **kwargs):
+        self.target = target
+        self.args = args
+        self.kwargs = kwargs
+        self.result = None
+        self.error = None
+        self._complete = False
+        
+    def run(self):
+        try:
+            self.result = self.target(*self.args, **self.kwargs)
+        except Exception as e:
+            self.error = e
+            print_message(f"Error in background task: {str(e)}")
+            traceback.print_exc()
+        finally:
+            self._complete = True
+    
+    @property
+    def complete(self):
+        return self._complete
+
+
+class GUI(MainProcess):
+    def __init__(self, master):
+        super().__init__(argparse.Namespace(), GUI=True)  # Initialize MainProcess with empty namespace
+        self.master = master
+        self.master.title("Settings GUI")
+        self.master.geometry("600x800")
+
+        icon = tk.PhotoImage(file="protify_logo.png")
+        # Set the window icon
+        self.master.iconphoto(True, icon)
+
+        # Dictionary to store Tkinter variables for settings
+        self.settings_vars = {}
+
+        # Create the Notebook widget
+        self.notebook = ttk.Notebook(master)
+        self.notebook.pack(fill='both', expand=True)
+
+        # Create frames for each settings tab
+        self.info_tab = ttk.Frame(self.notebook)
+        self.data_tab = ttk.Frame(self.notebook)
+        self.embed_tab = ttk.Frame(self.notebook)
+        self.model_tab = ttk.Frame(self.notebook)
+        self.probe_tab = ttk.Frame(self.notebook)
+        self.trainer_tab = ttk.Frame(self.notebook)
+        self.scikit_tab = ttk.Frame(self.notebook)
+        self.replay_tab = ttk.Frame(self.notebook)
+        self.viz_tab = ttk.Frame(self.notebook)
+
+        # Add tabs to the notebook
+        self.notebook.add(self.info_tab, text="Info")
+        self.notebook.add(self.model_tab, text="Model")
+        self.notebook.add(self.data_tab, text="Data")
+        self.notebook.add(self.embed_tab, text="Embedding")
+        self.notebook.add(self.probe_tab, text="Probe")
+        self.notebook.add(self.trainer_tab, text="Trainer")
+        self.notebook.add(self.scikit_tab, text="Scikit")
+        self.notebook.add(self.replay_tab, text="Replay")
+        self.notebook.add(self.viz_tab, text="Visualization")
+
+        # Build these lines
+        self.task_queue = queue.Queue()
+        self.thread_pool = ThreadPoolExecutor(max_workers=1)
+        self.current_task = None
+        
+        # Start the queue checker
+        self.check_task_queue()
+
+        # Build each tab
+        self.build_info_tab()
+        self.build_model_tab()
+        self.build_data_tab()
+        self.build_embed_tab()
+        self.build_probe_tab()
+        self.build_trainer_tab()
+        self.build_scikit_tab()
+        self.build_replay_tab()
+        self.build_viz_tab()
+
+    def check_task_queue(self):
+        """Periodically check for completed background tasks"""
+        if self.current_task and self.current_task.complete:
+            if self.current_task.error:
+                print_message(f"Task failed: {self.current_task.error}")
+            self.current_task = None
+            
+        if not self.current_task and not self.task_queue.empty():
+            self.current_task = self.task_queue.get()
+            self.thread_pool.submit(self.current_task.run)
+        
+        # Schedule next check
+        self.master.after(100, self.check_task_queue)
+    
+    def run_in_background(self, target, *args, **kwargs):
+        """Queue a task to run in background"""
+        task = BackgroundTask(target, *args, **kwargs)
+        self.task_queue.put(task)
+        return task
+
+    def _open_url(self, url):
+        """Open a URL in the default web browser"""
+        webbrowser.open_new_tab(url)
+        
+    def build_info_tab(self):
+        # Create a frame for IDs
+        id_frame = ttk.LabelFrame(self.info_tab, text="Identification")
+        id_frame.pack(fill="x", padx=10, pady=5)
+
+        # Huggingface Username
+        ttk.Label(id_frame, text="Huggingface Username:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["huggingface_username"] = tk.StringVar(value="Synthyra")
+        entry_huggingface_username = ttk.Entry(id_frame, textvariable=self.settings_vars["huggingface_username"], width=30)
+        entry_huggingface_username.grid(row=0, column=1, padx=10, pady=5)
+        self.add_help_button(id_frame, 0, 2, "Your Hugging Face username for model downloads and uploads.")
+
+        # Huggingface token
+        ttk.Label(id_frame, text="Huggingface Token:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["huggingface_token"] = tk.StringVar(value="")
+        entry_huggingface_token = ttk.Entry(id_frame, textvariable=self.settings_vars["huggingface_token"], width=30)
+        entry_huggingface_token.grid(row=1, column=1, padx=10, pady=5)
+        self.add_help_button(id_frame, 1, 2, "Your Hugging Face API token for accessing gated or private models.")
+
+        # Wandb API key 
+        ttk.Label(id_frame, text="Wandb API Key:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["wandb_api_key"] = tk.StringVar(value="")
+        entry_wandb_api_key = ttk.Entry(id_frame, textvariable=self.settings_vars["wandb_api_key"], width=30)
+        entry_wandb_api_key.grid(row=2, column=1, padx=10, pady=5)
+        self.add_help_button(id_frame, 2, 2, "Your Weights & Biases API key for experiment tracking.")
+
+        # Synthyra API key
+        ttk.Label(id_frame, text="Synthyra API Key:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["synthyra_api_key"] = tk.StringVar(value="")
+        entry_synthyra_api_key = ttk.Entry(id_frame, textvariable=self.settings_vars["synthyra_api_key"], width=30)
+        entry_synthyra_api_key.grid(row=3, column=1, padx=10, pady=5)
+        self.add_help_button(id_frame, 3, 2, "Your Synthyra API key for accessing premium features.")
+
+        # Create a frame for paths
+        paths_frame = ttk.LabelFrame(self.info_tab, text="Paths")
+        paths_frame.pack(fill="x", padx=10, pady=5)
+
+        ttk.Label(paths_frame, text='Home Directory:').grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["home_dir"] = tk.StringVar(value=os.getcwd())
+        entry_home_dir = ttk.Entry(paths_frame, textvariable=self.settings_vars["home_dir"], width=30)
+        entry_home_dir.grid(row=0, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 0, 2, "Home directory for Protify.")
+
+        # Log directory
+        ttk.Label(paths_frame, text="Log Directory:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["log_dir"] = tk.StringVar(value="logs")
+        entry_log_dir = ttk.Entry(paths_frame, textvariable=self.settings_vars["log_dir"], width=30)
+        entry_log_dir.grid(row=1, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 1, 2, "Directory where log files will be stored.")
+
+        # Results directory
+        ttk.Label(paths_frame, text="Results Directory:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["results_dir"] = tk.StringVar(value="results")
+        entry_results_dir = ttk.Entry(paths_frame, textvariable=self.settings_vars["results_dir"], width=30)
+        entry_results_dir.grid(row=2, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 2, 2, "Directory where results data will be stored.")
+
+        # Model save directory
+        ttk.Label(paths_frame, text="Model Save Directory:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["model_save_dir"] = tk.StringVar(value="weights")
+        entry_model_save = ttk.Entry(paths_frame, textvariable=self.settings_vars["model_save_dir"], width=30)
+        entry_model_save.grid(row=3, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 3, 2, "Directory where trained models will be saved.")
+
+        ttk.Label(paths_frame, text="Plots Directory:").grid(row=4, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["plots_dir"] = tk.StringVar(value="plots")
+        entry_plots_dir = ttk.Entry(paths_frame, textvariable=self.settings_vars["plots_dir"], width=30)
+        entry_plots_dir.grid(row=4, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 4, 2, "Directory where plots and visualizations will be saved.")
+
+        # Embedding save directory
+        ttk.Label(paths_frame, text="Embedding Save Directory:").grid(row=5, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["embedding_save_dir"] = tk.StringVar(value="embeddings")
+        entry_embed_save = ttk.Entry(paths_frame, textvariable=self.settings_vars["embedding_save_dir"], width=30)
+        entry_embed_save.grid(row=5, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 5, 2, "Directory where computed embeddings will be saved.")
+
+        # Download directory
+        ttk.Label(paths_frame, text="Download Directory:").grid(row=6, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["download_dir"] = tk.StringVar(value="Synthyra/mean_pooled_embeddings")
+        entry_download = ttk.Entry(paths_frame, textvariable=self.settings_vars["download_dir"], width=30)
+        entry_download.grid(row=6, column=1, padx=10, pady=5)
+        self.add_help_button(paths_frame, 6, 2, "HuggingFace repository path for downloading pre-computed embeddings.")
+
+        # button to start logging
+        start_logging_button = ttk.Button(self.info_tab, text="Start session", command=self._session_start)
+        start_logging_button.pack(pady=10)
+        
+        # Add logo and website link at the bottom of the info tab
+        try:
+            original_logo = tk.PhotoImage(file="synthyra_logo.png")
+            # Make logo even smaller (subsample by factor of 3)
+            logo = original_logo.subsample(3, 3)
+            
+            # Create frame to hold logo and button side by side
+            bottom_frame = ttk.Frame(self.info_tab)
+            bottom_frame.pack(pady=(10, 20), fill="x")
+            
+            # Place logo on the left side
+            logo_label = ttk.Label(bottom_frame, image=logo, cursor="hand2")
+            logo_label.image = logo  # Keep a reference to prevent garbage collection
+            logo_label.pack(side=tk.LEFT, padx=(20, 10))
+            # Bind click event to the logo
+            logo_label.bind("<Button-1>", lambda e: self._open_url("https://synthyra.com"))
+            
+            # Add a "Visit Website" button on the right side
+            visit_btn = ttk.Button(
+                bottom_frame,
+                text="Visit Synthyra.com",
+                command=lambda: self._open_url("https://synthyra.com"),
+                style="Link.TButton"
+            )
+            
+            # Create a special style for the link button
+            style = ttk.Style()
+            style.configure("Link.TButton", font=("Helvetica", 12), foreground="blue")
+            
+            visit_btn.pack(side=tk.LEFT, padx=(10, 20), pady=10)
+            
+        except Exception as e:
+            print_message(f"Error setting up logo and link: {str(e)}")
+
+    def build_model_tab(self):
+        ttk.Label(self.model_tab, text="Model Names:").grid(row=0, column=0, padx=10, pady=5, sticky="nw")
+
+        self.model_listbox = tk.Listbox(self.model_tab, selectmode="extended", height=30)
+        for model_name in standard_models:
+            self.model_listbox.insert(tk.END, model_name)
+        self.model_listbox.grid(row=0, column=1, padx=10, pady=5, sticky="nw")
+        self.add_help_button(self.model_tab, 0, 2, "Select the language models to use for embedding. Multiple models can be selected.")
+
+        run_button = ttk.Button(self.model_tab, text="Select Models", command=self._select_models)
+        run_button.grid(row=99, column=0, columnspan=2, pady=(10, 10))
+
+    def build_data_tab(self):
+        # Max length (Spinbox)
+        ttk.Label(self.data_tab, text="Max Sequence Length:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["max_length"] = tk.IntVar(value=1024)
+        spin_max_length = ttk.Spinbox(
+            self.data_tab,
+            from_=1,
+            to=32768,
+            textvariable=self.settings_vars["max_length"]
+        )
+        spin_max_length.grid(row=0, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.data_tab, 0, 2, "Maximum length of sequences (in tokens) to process.")
+
+        # Trim (Checkbox)
+        ttk.Label(self.data_tab, text="Trim Sequences:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["trim"] = tk.BooleanVar(value=False)
+        check_trim = ttk.Checkbutton(
+            self.data_tab,
+            variable=self.settings_vars["trim"]
+        )
+        check_trim.grid(row=1, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.data_tab, 1, 2, "Whether to trim sequences to the specified max length.")
+
+        # Delimiter for data files
+        ttk.Label(self.data_tab, text="Delimiter:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["delimiter"] = tk.StringVar(value=",")
+        entry_delimiter = ttk.Entry(self.data_tab, textvariable=self.settings_vars["delimiter"], width=5)
+        entry_delimiter.grid(row=2, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.data_tab, 2, 2, "Character used to separate columns in CSV data files.")
+
+        # Column names for data files (comma-separated)
+        ttk.Label(self.data_tab, text="Column Names (comma-separated):").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["col_names"] = tk.StringVar(value="seqs,labels")
+        entry_col_names = ttk.Entry(self.data_tab, textvariable=self.settings_vars["col_names"], width=20)
+        entry_col_names.grid(row=3, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.data_tab, 3, 2, "Names of columns in data files, separate with commas.")
+
+        # Label + Listbox for dataset names
+        ttk.Label(self.data_tab, text="Dataset Names:").grid(row=4, column=0, padx=10, pady=5, sticky="nw")
+        self.data_listbox = tk.Listbox(self.data_tab, selectmode="extended", height=25, width=25)
+        for dataset_name in supported_datasets:
+            if dataset_name not in internal_datasets:
+                self.data_listbox.insert(tk.END, dataset_name)
+        self.data_listbox.grid(row=4, column=1, padx=10, pady=5, sticky="nw")
+        self.add_help_button(self.data_tab, 4, 2, "Select datasets to use. Multiple datasets can be selected.")
+
+        run_button = ttk.Button(self.data_tab, text="Get Data", command=self._get_data)
+        run_button.grid(row=99, column=0, columnspan=2, pady=(10, 10))
+
+    def build_embed_tab(self):
+        # batch_size
+        ttk.Label(self.embed_tab, text="Batch Size:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["batch_size"] = tk.IntVar(value=4)
+        spin_batch_size = ttk.Spinbox(self.embed_tab, from_=1, to=1024, textvariable=self.settings_vars["batch_size"])
+        spin_batch_size.grid(row=1, column=1, padx=10, pady=5)
+        self.add_help_button(self.embed_tab, 1, 2, "Number of sequences to process at once during embedding.")
+
+        # num_workers
+        ttk.Label(self.embed_tab, text="Num Workers:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["num_workers"] = tk.IntVar(value=0)
+        spin_num_workers = ttk.Spinbox(self.embed_tab, from_=0, to=64, textvariable=self.settings_vars["num_workers"])
+        spin_num_workers.grid(row=2, column=1, padx=10, pady=5)
+        self.add_help_button(self.embed_tab, 2, 2, "Number of worker processes for data loading. 0 means main process only.")
+
+        # download_embeddings
+        ttk.Label(self.embed_tab, text="Download Embeddings:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["download_embeddings"] = tk.BooleanVar(value=False)
+        check_download = ttk.Checkbutton(self.embed_tab, variable=self.settings_vars["download_embeddings"])
+        check_download.grid(row=3, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.embed_tab, 3, 2, "Whether to download pre-computed embeddings from HuggingFace instead of computing them.")
+
+        # matrix_embed
+        ttk.Label(self.embed_tab, text="Matrix Embedding:").grid(row=4, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["matrix_embed"] = tk.BooleanVar(value=False)
+        check_matrix = ttk.Checkbutton(self.embed_tab, variable=self.settings_vars["matrix_embed"])
+        check_matrix.grid(row=4, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.embed_tab, 4, 2, "Whether to use matrix embedding (full embedding matrices) instead of pooled embeddings.")
+
+        # pooling_types
+        ttk.Label(self.embed_tab, text="Pooling Types (comma-separated):").grid(row=5, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["embedding_pooling_types"] = tk.StringVar(value="mean")
+        entry_pooling = ttk.Entry(self.embed_tab, textvariable=self.settings_vars["embedding_pooling_types"], width=20)
+        entry_pooling.grid(row=5, column=1, padx=10, pady=5)
+        self.add_help_button(self.embed_tab, 5, 2, "Types of pooling to apply to embeddings, separate with commas.")
+        
+        ttk.Label(self.embed_tab, text="Options: mean, max, min, norm, prod, median, std, var, cls, parti").grid(row=6, column=0, columnspan=2, padx=10, pady=2, sticky="w")
+
+        # embed_dtype
+        ttk.Label(self.embed_tab, text="Embedding DType:").grid(row=7, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["embed_dtype"] = tk.StringVar(value="float32")
+        combo_dtype = ttk.Combobox(
+            self.embed_tab,
+            textvariable=self.settings_vars["embed_dtype"],
+            values=["float32", "float16", "bfloat16", "float8_e4m3fn", "float8_e5m2"]
+        )
+        combo_dtype.grid(row=7, column=1, padx=10, pady=5)
+        self.add_help_button(self.embed_tab, 7, 2, "Data type to use for storing embeddings (affects precision and size).")
+
+        # sql
+        ttk.Label(self.embed_tab, text="Use SQL:").grid(row=8, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["sql"] = tk.BooleanVar(value=False)
+        check_sql = ttk.Checkbutton(self.embed_tab, variable=self.settings_vars["sql"])
+        check_sql.grid(row=8, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.embed_tab, 8, 2, "Whether to use SQL database for storing embeddings instead of files.")
+
+        run_button = ttk.Button(self.embed_tab, text="Embed sequences to disk", command=self._get_embeddings)
+        run_button.grid(row=99, column=0, columnspan=2, pady=(10, 10))
+
+    def build_probe_tab(self):
+        # Probe Type
+        ttk.Label(self.probe_tab, text="Probe Type:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["probe_type"] = tk.StringVar(value="linear")
+        combo_probe = ttk.Combobox(
+            self.probe_tab,
+            textvariable=self.settings_vars["probe_type"],
+            values=["linear", "transformer", "retrievalnet"]
+        )
+        combo_probe.grid(row=0, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 0, 2, "Type of probe architecture to use (linear, transformer, or retrievalnet).")
+
+        # Tokenwise
+        ttk.Label(self.probe_tab, text="Tokenwise:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["tokenwise"] = tk.BooleanVar(value=False)
+        check_tokenwise = ttk.Checkbutton(self.probe_tab, variable=self.settings_vars["tokenwise"])
+        check_tokenwise.grid(row=1, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 1, 2, "Whether to use token-wise prediction (operate on each token) instead of sequence-level.")
+
+        # Pre Layer Norm
+        ttk.Label(self.probe_tab, text="Pre Layer Norm:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["pre_ln"] = tk.BooleanVar(value=True)
+        check_pre_ln = ttk.Checkbutton(self.probe_tab, variable=self.settings_vars["pre_ln"])
+        check_pre_ln.grid(row=2, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 2, 2, "Whether to use pre-layer normalization in transformer architecture.")
+
+        # Number of Layers
+        ttk.Label(self.probe_tab, text="Number of Layers:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["n_layers"] = tk.IntVar(value=1)
+        spin_n_layers = ttk.Spinbox(self.probe_tab, from_=1, to=100, textvariable=self.settings_vars["n_layers"])
+        spin_n_layers.grid(row=3, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 3, 2, "Number of layers in the probe architecture.")
+
+        # Hidden Dimension
+        ttk.Label(self.probe_tab, text="Hidden Dimension:").grid(row=4, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["hidden_dim"] = tk.IntVar(value=8192)
+        spin_hidden_dim = ttk.Spinbox(self.probe_tab, from_=1, to=10000, textvariable=self.settings_vars["hidden_dim"])
+        spin_hidden_dim.grid(row=4, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 4, 2, "Size of hidden dimension in the probe model.")
+
+        # Dropout
+        ttk.Label(self.probe_tab, text="Dropout:").grid(row=5, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["dropout"] = tk.DoubleVar(value=0.2)
+        spin_dropout = ttk.Spinbox(self.probe_tab, from_=0.0, to=1.0, increment=0.1, textvariable=self.settings_vars["dropout"])
+        spin_dropout.grid(row=5, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 5, 2, "Dropout probability for regularization (0.0-1.0).")
+
+        # Transformer Probe Settings
+        ttk.Label(self.probe_tab, text="=== Transformer Probe Settings ===").grid(row=6, column=0, columnspan=2, pady=10)
+
+        # FF Dimension
+        ttk.Label(self.probe_tab, text="Classifier Dimension:").grid(row=7, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["classifier_dim"] = tk.IntVar(value=4096)
+        spin_classifier_dim = ttk.Spinbox(self.probe_tab, from_=1, to=10000, textvariable=self.settings_vars["classifier_dim"])
+        spin_classifier_dim.grid(row=7, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 7, 2, "Dimension of the classifier/feedforward layer in transformer probe.")
+
+        # Classifier Dropout
+        ttk.Label(self.probe_tab, text="Classifier Dropout:").grid(row=8, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["classifier_dropout"] = tk.DoubleVar(value=0.2)
+        spin_class_dropout = ttk.Spinbox(self.probe_tab, from_=0.0, to=1.0, increment=0.1, textvariable=self.settings_vars["classifier_dropout"])
+        spin_class_dropout.grid(row=8, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 8, 2, "Dropout probability in the classifier layer (0.0-1.0).")
+
+        # Number of Heads
+        ttk.Label(self.probe_tab, text="Number of Heads:").grid(row=9, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["n_heads"] = tk.IntVar(value=4)
+        spin_n_heads = ttk.Spinbox(self.probe_tab, from_=1, to=32, textvariable=self.settings_vars["n_heads"])
+        spin_n_heads.grid(row=9, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 9, 2, "Number of attention heads in transformer probe.")
+
+        # Rotary
+        ttk.Label(self.probe_tab, text="Rotary:").grid(row=10, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["rotary"] = tk.BooleanVar(value=True)
+        check_rotary = ttk.Checkbutton(self.probe_tab, variable=self.settings_vars["rotary"])
+        check_rotary.grid(row=10, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 10, 2, "Whether to use rotary position embeddings in transformer.")
+
+        # Pooling Types
+        ttk.Label(self.probe_tab, text="Pooling Types (comma-separated):").grid(row=11, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["probe_pooling_types"] = tk.StringVar(value="mean, cls")
+        entry_pooling = ttk.Entry(self.probe_tab, textvariable=self.settings_vars["probe_pooling_types"], width=20)
+        entry_pooling.grid(row=11, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 11, 2, "Types of pooling to use in the probe model, separate with commas.")
+        
+        # Transformer Dropout
+        ttk.Label(self.probe_tab, text="Transformer Dropout:").grid(row=12, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["transformer_dropout"] = tk.DoubleVar(value=0.1)
+        spin_transformer_dropout = ttk.Spinbox(self.probe_tab, from_=0.0, to=1.0, increment=0.1, textvariable=self.settings_vars["transformer_dropout"])
+        spin_transformer_dropout.grid(row=12, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 12, 2, "Dropout probability in the transformer layers (0.0-1.0).")
+        
+        # Save Model
+        ttk.Label(self.probe_tab, text="Save Model:").grid(row=13, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["save_model"] = tk.BooleanVar(value=False)
+        check_save_model = ttk.Checkbutton(self.probe_tab, variable=self.settings_vars["save_model"])
+        check_save_model.grid(row=13, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 13, 2, "Whether to save the trained probe model to disk.")
+        
+        # Production Model
+        ttk.Label(self.probe_tab, text="Production Model:").grid(row=14, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["production_model"] = tk.BooleanVar(value=False)
+        check_prod_model = ttk.Checkbutton(self.probe_tab, variable=self.settings_vars["production_model"])
+        check_prod_model.grid(row=14, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 14, 2, "Whether to prepare the model for production deployment.")
+
+        # LoRA Settings Section
+        ttk.Label(self.probe_tab, text="=== LoRA Settings ===").grid(row=15, column=0, columnspan=2, pady=10)
+        
+        # Lora checkbox
+        ttk.Label(self.probe_tab, text="Use LoRA:").grid(row=16, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["use_lora"] = tk.BooleanVar(value=False)
+        check_lora = ttk.Checkbutton(self.probe_tab, variable=self.settings_vars["use_lora"])
+        check_lora.grid(row=16, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.probe_tab, 16, 2, "Whether to use Low-Rank Adaptation (LoRA) for fine-tuning.")
+
+        # LoRA r
+        ttk.Label(self.probe_tab, text="LoRA r:").grid(row=17, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["lora_r"] = tk.IntVar(value=8)
+        spin_lora_r = ttk.Spinbox(self.probe_tab, from_=1, to=128, textvariable=self.settings_vars["lora_r"])
+        spin_lora_r.grid(row=17, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 17, 2, "Rank parameter r for LoRA (lower = more efficient, higher = more expressive).")
+
+        # LoRA alpha
+        ttk.Label(self.probe_tab, text="LoRA alpha:").grid(row=18, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["lora_alpha"] = tk.DoubleVar(value=32.0)
+        spin_lora_alpha = ttk.Spinbox(self.probe_tab, from_=1.0, to=128.0, increment=1.0, textvariable=self.settings_vars["lora_alpha"])
+        spin_lora_alpha.grid(row=18, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 18, 2, "Alpha parameter for LoRA, controls update scale.")
+
+        # LoRA dropout
+        ttk.Label(self.probe_tab, text="LoRA dropout:").grid(row=19, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["lora_dropout"] = tk.DoubleVar(value=0.01)
+        spin_lora_dropout = ttk.Spinbox(self.probe_tab, from_=0.0, to=0.5, increment=0.01, textvariable=self.settings_vars["lora_dropout"])
+        spin_lora_dropout.grid(row=19, column=1, padx=10, pady=5)
+        self.add_help_button(self.probe_tab, 19, 2, "Dropout probability for LoRA layers (0.0-0.5).")
+        
+        # Add a button to create the probe
+        run_button = ttk.Button(self.probe_tab, text="Save Probe Arguments", command=self._create_probe_args)
+        run_button.grid(row=99, column=0, columnspan=2, pady=(10, 10))
+
+    def build_trainer_tab(self):
+        # Hybrid Probe checkbox
+        ttk.Label(self.trainer_tab, text="Hybrid Probe:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["hybrid_probe"] = tk.BooleanVar(value=False)
+        check_hybrid_probe = ttk.Checkbutton(self.trainer_tab, variable=self.settings_vars["hybrid_probe"])
+        check_hybrid_probe.grid(row=0, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.trainer_tab, 0, 2, "Whether to use hybrid probe (combines neural and linear probes).")
+
+        # Full finetuning checkbox
+        ttk.Label(self.trainer_tab, text="Full Finetuning:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["full_finetuning"] = tk.BooleanVar(value=False)
+        check_full_ft = ttk.Checkbutton(self.trainer_tab, variable=self.settings_vars["full_finetuning"])
+        check_full_ft.grid(row=1, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.trainer_tab, 1, 2, "Whether to perform full finetuning of the entire model.")
+
+        # num_epochs
+        ttk.Label(self.trainer_tab, text="Number of Epochs:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["num_epochs"] = tk.IntVar(value=200)
+        spin_num_epochs = ttk.Spinbox(self.trainer_tab, from_=1, to=1000, textvariable=self.settings_vars["num_epochs"])
+        spin_num_epochs.grid(row=2, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 2, 2, "Number of training epochs (complete passes through the dataset).")
+
+        # probe_batch_size
+        ttk.Label(self.trainer_tab, text="Probe Batch Size:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["probe_batch_size"] = tk.IntVar(value=64)
+        spin_probe_batch_size = ttk.Spinbox(self.trainer_tab, from_=1, to=1000, textvariable=self.settings_vars["probe_batch_size"])
+        spin_probe_batch_size.grid(row=3, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 3, 2, "Batch size for probe training.")
+
+        # base_batch_size
+        ttk.Label(self.trainer_tab, text="Base Batch Size:").grid(row=4, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["base_batch_size"] = tk.IntVar(value=4)
+        spin_base_batch_size = ttk.Spinbox(self.trainer_tab, from_=1, to=1000, textvariable=self.settings_vars["base_batch_size"])
+        spin_base_batch_size.grid(row=4, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 4, 2, "Batch size for base model training.")
+
+        # probe_grad_accum
+        ttk.Label(self.trainer_tab, text="Probe Grad Accum:").grid(row=5, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["probe_grad_accum"] = tk.IntVar(value=1)
+        spin_probe_grad_accum = ttk.Spinbox(self.trainer_tab, from_=1, to=100, textvariable=self.settings_vars["probe_grad_accum"])
+        spin_probe_grad_accum.grid(row=5, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 5, 2, "Gradient accumulation steps for probe training.")
+
+        # base_grad_accum
+        ttk.Label(self.trainer_tab, text="Base Grad Accum:").grid(row=6, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["base_grad_accum"] = tk.IntVar(value=8)
+        spin_base_grad_accum = ttk.Spinbox(self.trainer_tab, from_=1, to=100, textvariable=self.settings_vars["base_grad_accum"])
+        spin_base_grad_accum.grid(row=6, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 6, 2, "Gradient accumulation steps for base model training.")
+
+        # lr
+        ttk.Label(self.trainer_tab, text="Learning Rate:").grid(row=7, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["lr"] = tk.DoubleVar(value=1e-4)
+        spin_lr = ttk.Spinbox(self.trainer_tab, from_=1e-6, to=1e-2, increment=1e-5, textvariable=self.settings_vars["lr"])
+        spin_lr.grid(row=7, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 7, 2, "Learning rate for optimizer. Controls step size during training.")
+
+        # weight_decay
+        ttk.Label(self.trainer_tab, text="Weight Decay:").grid(row=8, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["weight_decay"] = tk.DoubleVar(value=0.00)
+        spin_weight_decay = ttk.Spinbox(self.trainer_tab, from_=0.0, to=1.0, increment=0.01, textvariable=self.settings_vars["weight_decay"])
+        spin_weight_decay.grid(row=8, column=1, padx=10, pady=5)
+        self.add_help_button(self.trainer_tab, 8, 2, "L2 regularization factor to prevent overfitting (0.0-1.0).")
+
+        # patience
+        ttk.Label(self.trainer_tab, text="Patience:").grid(row=9, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["patience"] = tk.IntVar(value=1)
+        spin_patience = ttk.Spinbox(self.trainer_tab, from_=1, to=100, textvariable=self.settings_vars["patience"])
+        spin_patience.grid(row=9, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.trainer_tab, 9, 2, "Number of epochs with no improvement after which training will stop.")
+
+        # Random Seed
+        ttk.Label(self.trainer_tab, text="Random Seed:").grid(row=10, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["seed"] = tk.IntVar(value=42)
+        spin_seed = ttk.Spinbox(self.trainer_tab, from_=0, to=10000, textvariable=self.settings_vars["seed"])
+        spin_seed.grid(row=10, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(self.trainer_tab, 10, 2, "Random seed for reproducibility of experiments.")
+
+        run_button = ttk.Button(self.trainer_tab, text="Run trainer", command=self._run_trainer)
+        run_button.grid(row=99, column=0, columnspan=2, pady=(10, 10))
+
+    def build_scikit_tab(self):
+        # Create a frame for scikit settings
+        scikit_frame = ttk.LabelFrame(self.scikit_tab, text="Scikit-Learn Settings")
+        scikit_frame.pack(fill="x", padx=10, pady=5)
+        
+        # Use Scikit
+        ttk.Label(scikit_frame, text="Use Scikit:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["use_scikit"] = tk.BooleanVar(value=False)
+        check_scikit = ttk.Checkbutton(scikit_frame, variable=self.settings_vars["use_scikit"])
+        check_scikit.grid(row=0, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(scikit_frame, 0, 2, "Whether to use scikit-learn models instead of neural networks.")
+
+        # Scikit Iterations
+        ttk.Label(scikit_frame, text="Scikit Iterations:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["scikit_n_iter"] = tk.IntVar(value=10)
+        spin_scikit_n_iter = ttk.Spinbox(scikit_frame, from_=1, to=1000, textvariable=self.settings_vars["scikit_n_iter"])
+        spin_scikit_n_iter.grid(row=1, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(scikit_frame, 1, 2, "Number of iterations for iterative scikit-learn models.")
+
+        # Scikit CV Folds
+        ttk.Label(scikit_frame, text="Scikit CV Folds:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["scikit_cv"] = tk.IntVar(value=3)
+        spin_scikit_cv = ttk.Spinbox(scikit_frame, from_=1, to=10, textvariable=self.settings_vars["scikit_cv"])
+        spin_scikit_cv.grid(row=2, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(scikit_frame, 2, 2, "Number of cross-validation folds for model evaluation.")
+
+        # Scikit Random State
+        ttk.Label(scikit_frame, text="Scikit Random State:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["scikit_random_state"] = tk.IntVar(value=42)
+        spin_scikit_rand = ttk.Spinbox(scikit_frame, from_=0, to=10000, textvariable=self.settings_vars["scikit_random_state"])
+        spin_scikit_rand.grid(row=3, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(scikit_frame, 3, 2, "Random seed for scikit-learn models to ensure reproducibility.")
+
+        # Scikit Model Name
+        ttk.Label(scikit_frame, text="Scikit Model Name (optional):").grid(row=4, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["scikit_model_name"] = tk.StringVar(value="")
+        entry_scikit_name = ttk.Entry(scikit_frame, textvariable=self.settings_vars["scikit_model_name"], width=30)
+        entry_scikit_name.grid(row=4, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(scikit_frame, 4, 2, "Optional name for the scikit-learn model. Leave blank to use default.")
+        
+        # Number of Jobs/Processors
+        ttk.Label(scikit_frame, text="Number of Jobs:").grid(row=5, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["n_jobs"] = tk.IntVar(value=1)
+        spin_n_jobs = ttk.Spinbox(scikit_frame, from_=1, to=32, textvariable=self.settings_vars["n_jobs"])
+        spin_n_jobs.grid(row=5, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(scikit_frame, 5, 2, "Number of CPU cores to use for parallel processing. Use -1 for all cores.")
+
+        run_button = ttk.Button(self.scikit_tab, text="Run Scikit Models", command=self._run_scikit)
+        run_button.pack(pady=(20, 10))
+
+    def build_replay_tab(self):
+        # Create a frame for replay settings
+        replay_frame = ttk.LabelFrame(self.replay_tab, text="Log Replay Settings")
+        replay_frame.pack(fill="x", padx=10, pady=5)
+
+        # Replay log path
+        ttk.Label(replay_frame, text="Replay Log Path:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["replay_path"] = tk.StringVar(value="")
+        entry_replay = ttk.Entry(replay_frame, textvariable=self.settings_vars["replay_path"], width=40)
+        entry_replay.grid(row=0, column=1, padx=10, pady=5)
+        self.add_help_button(replay_frame, 0, 2, "Path to the log file to replay. Use Browse button to select a file.")
+
+        # Browse button for selecting log file
+        browse_button = ttk.Button(replay_frame, text="Browse", command=self._browse_replay_log)
+        browse_button.grid(row=0, column=2, padx=5, pady=5)
+
+        # Start replay button
+        replay_button = ttk.Button(replay_frame, text="Start Replay", command=self._start_replay)
+        replay_button.grid(row=1, column=0, columnspan=3, pady=20)
+
+    def build_viz_tab(self):
+        # Create a frame for visualization settings
+        viz_frame = ttk.LabelFrame(self.viz_tab, text="Visualization Settings")
+        viz_frame.pack(fill="x", padx=10, pady=5)
+
+        # Result ID entry
+        ttk.Label(viz_frame, text="Result ID:").grid(row=0, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["result_id"] = tk.StringVar(value="")
+        entry_result_id = ttk.Entry(viz_frame, textvariable=self.settings_vars["result_id"], width=30)
+        entry_result_id.grid(row=0, column=1, padx=10, pady=5)
+        self.add_help_button(viz_frame, 0, 2, "ID of the result to visualize. Will look for results/{result_id}.tsv")
+
+        # Results file path
+        ttk.Label(viz_frame, text="Results File:").grid(row=1, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["results_file"] = tk.StringVar(value="")
+        entry_results_file = ttk.Entry(viz_frame, textvariable=self.settings_vars["results_file"], width=30)
+        entry_results_file.grid(row=1, column=1, padx=10, pady=5)
+        
+        # Browse button for selecting results file directly
+        browse_button = ttk.Button(viz_frame, text="Browse", command=self._browse_results_file)
+        browse_button.grid(row=1, column=2, padx=5, pady=5)
+        
+        # Use current run checkbox
+        ttk.Label(viz_frame, text="Use Current Run:").grid(row=2, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["use_current_run"] = tk.BooleanVar(value=True)
+        check_current_run = ttk.Checkbutton(viz_frame, variable=self.settings_vars["use_current_run"])
+        check_current_run.grid(row=2, column=1, padx=10, pady=5, sticky="w")
+        self.add_help_button(viz_frame, 2, 2, "Use results from the current run.")
+
+        # Output directory for plots
+        ttk.Label(viz_frame, text="Output Directory:").grid(row=3, column=0, padx=10, pady=5, sticky="w")
+        self.settings_vars["viz_output_dir"] = tk.StringVar(value="plots")
+        entry_output_dir = ttk.Entry(viz_frame, textvariable=self.settings_vars["viz_output_dir"], width=30)
+        entry_output_dir.grid(row=3, column=1, padx=10, pady=5)
+        self.add_help_button(viz_frame, 3, 2, "Directory where plots will be saved.")
+
+
+        # Generate plots button
+        generate_button = ttk.Button(viz_frame, text="Generate Plots", command=self._generate_plots)
+        generate_button.grid(row=99, column=0, columnspan=3, pady=20)
+
+    def add_help_button(self, parent, row, column, help_text):
+        """Add a small help button that displays information when clicked"""
+        help_button = ttk.Button(parent, text="?", width=2, 
+                                command=lambda: messagebox.showinfo("Help", help_text))
+        help_button.grid(row=row, column=column, padx=(0,5), pady=5)
+        return help_button
+
+    def _session_start(self):
+        print_message("Starting Protify session...")
+        # Update session variables
+        hf_token = self.settings_vars["huggingface_token"].get()
+        synthyra_api_key = self.settings_vars["synthyra_api_key"].get()
+        wandb_api_key = self.settings_vars["wandb_api_key"].get()
+
+        def background_login():
+            if hf_token:
+                from huggingface_hub import login
+                login(hf_token)
+                print_message('Logged in to Hugging Face')
+            if wandb_api_key:
+                print_message('Wandb not integrated yet')
+            if synthyra_api_key:
+                print_message('Synthyra API not integrated yet')
+            
+            self.full_args.hf_username = self.settings_vars["huggingface_username"].get()
+            self.full_args.hf_token = hf_token
+            self.full_args.synthyra_api_key = synthyra_api_key
+            self.full_args.wandb_api_key = wandb_api_key
+            self.full_args.home_dir = self.settings_vars["home_dir"].get()
+
+            def _make_true_dir(path):
+                true_path = os.path.join(self.full_args.home_dir, path)
+                os.makedirs(true_path, exist_ok=True)
+                return true_path
+
+            self.full_args.log_dir = _make_true_dir(self.settings_vars["log_dir"].get())
+            self.full_args.results_dir = _make_true_dir(self.settings_vars["results_dir"].get())
+            self.full_args.model_save_dir = _make_true_dir(self.settings_vars["model_save_dir"].get())
+            self.full_args.plots_dir = _make_true_dir(self.settings_vars["plots_dir"].get())
+            self.full_args.embedding_save_dir = _make_true_dir(self.settings_vars["embedding_save_dir"].get())
+            self.full_args.download_dir = _make_true_dir(self.settings_vars["download_dir"].get())
+
+            self.full_args.replay_path = None
+            self.logger_args = SimpleNamespace(**self.full_args.__dict__)
+            self.start_log_gui()
+
+            print_message(f"Session and logging started for id {self.random_id}")
+            print_done()
+        
+        self.run_in_background(background_login)
+
+    def _select_models(self):
+        print_message("Selecting models...")
+        # Gather selected model names
+        selected_indices = self.model_listbox.curselection()
+        selected_models = [self.model_listbox.get(i) for i in selected_indices]
+
+        # If no selection, default to the entire standard_benchmark
+        if not selected_models:
+            selected_models = standard_models
+
+        # Update full_args with model settings
+        self.full_args.model_names = selected_models
+        print_message(self.full_args.model_names)
+        # Create model args from full args
+        self.model_args = BaseModelArguments(**self.full_args.__dict__)
+
+        print("Model Args:")
+        for k, v in self.model_args.__dict__.items():
+            if k != 'model_names':
+                print(f"{k}:\n{v}")
+        print("=========================\n")
+        args_dict = {k: v for k, v in self.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}
+        self.logger_args = SimpleNamespace(**args_dict)
+        self._write_args()
+        print_done()
+
+    def _get_data(self):
+        print_message("=== Getting Data ===")
+        print_message("Loading and preparing datasets...")
+        
+        # Gather settings
+        selected_indices = self.data_listbox.curselection()
+        selected_datasets = [self.data_listbox.get(i) for i in selected_indices]
+        
+        if not selected_datasets:
+            selected_datasets = standard_data_benchmark
+            
+        def background_get_data():
+            # Update full_args with data settings
+            self.full_args.data_names = selected_datasets
+            self.full_args.data_dirs = []
+            self.full_args.max_length = self.settings_vars["max_length"].get()
+            self.full_args.trim = self.settings_vars["trim"].get()
+            self.full_args.delimiter = self.settings_vars["delimiter"].get()
+            self.full_args.col_names = self.settings_vars["col_names"].get().split(",")
+
+            # Update mixin attributes
+            self._max_length = self.full_args.max_length
+            self._trim = self.full_args.trim
+            self._delimiter = self.full_args.delimiter
+            self._col_names = self.full_args.col_names
+
+            # Create data args and get datasets
+            self.data_args = DataArguments(**self.full_args.__dict__)
+            args_dict = {k: v for k, v in self.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}
+            self.logger_args = SimpleNamespace(**args_dict)
+
+            self._write_args()
+            self.get_datasets()
+            print_message("Data downloaded and stored")
+            print_done()
+            
+        self.run_in_background(background_get_data)
+
+    def _get_embeddings(self):
+        if not self.all_seqs:
+            print_message('Sequences are not loaded yet. Please run the data tab first.')
+            return
+            
+        # Gather settings
+        print_message("Computing embeddings...")
+        pooling_str = self.settings_vars["embedding_pooling_types"].get().strip()
+        pooling_list = [p.strip() for p in pooling_str.split(",") if p.strip()]
+        dtype_str = self.settings_vars["embed_dtype"].get()
+        dtype_val = self.dtype_map.get(dtype_str, torch.float32)
+        
+        def background_get_embeddings():
+            # Update full args
+            self.full_args.all_seqs = self.all_seqs
+            self.full_args.embedding_batch_size = self.settings_vars["batch_size"].get()
+            self.full_args.embedding_num_workers = self.settings_vars["num_workers"].get()
+            self.full_args.download_embeddings = self.settings_vars["download_embeddings"].get()
+            self.full_args.matrix_embed = self.settings_vars["matrix_embed"].get()
+            self.full_args.embedding_pooling_types = pooling_list
+            self.full_args.save_embeddings = True
+            self.full_args.embed_dtype = dtype_val
+            self.full_args.sql = self.settings_vars["sql"].get()
+            self._sql = self.full_args.sql
+            self._full = self.full_args.matrix_embed
+            
+            self.embedding_args = EmbeddingArguments(**self.full_args.__dict__)
+            args_dict = {k: v for k, v in self.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}
+            self.logger_args = SimpleNamespace(**args_dict)
+            self._write_args()
+            
+            print_message("Saving embeddings to disk")
+            self.save_embeddings_to_disk()
+            print_message("Embeddings saved to disk")
+            print_done()
+            
+        self.run_in_background(background_get_embeddings)
+
+    def _create_probe_args(self):
+        print_message("Creating probe arguments...")
+        
+        # Convert pooling types string to list
+        probe_pooling_types = [p.strip() for p in self.settings_vars["probe_pooling_types"].get().split(",")]
+        
+        # Update full_args with probe settings
+        self.full_args.probe_type = self.settings_vars["probe_type"].get()
+        self.full_args.tokenwise = self.settings_vars["tokenwise"].get()
+        self.full_args.hidden_dim = self.settings_vars["hidden_dim"].get()
+        self.full_args.dropout = self.settings_vars["dropout"].get()
+        self.full_args.n_layers = self.settings_vars["n_layers"].get()
+        self.full_args.pre_ln = self.settings_vars["pre_ln"].get()
+        self.full_args.classifier_dim = self.settings_vars["classifier_dim"].get()
+        self.full_args.transformer_dropout = self.settings_vars["transformer_dropout"].get()
+        self.full_args.classifier_dropout = self.settings_vars["classifier_dropout"].get()
+        self.full_args.n_heads = self.settings_vars["n_heads"].get()
+        self.full_args.rotary = self.settings_vars["rotary"].get()
+        self.full_args.probe_pooling_types = probe_pooling_types
+        self.full_args.save_model = self.settings_vars["save_model"].get()
+        self.full_args.production_model = self.settings_vars["production_model"].get()
+        self.full_args.use_lora = self.settings_vars["use_lora"].get()
+        self.full_args.lora_r = self.settings_vars["lora_r"].get()
+        self.full_args.lora_alpha = self.settings_vars["lora_alpha"].get()
+        self.full_args.lora_dropout = self.settings_vars["lora_dropout"].get()
+
+        # Create probe args from full args
+        self.probe_args = ProbeArguments(**self.full_args.__dict__)
+        
+        print_message("Probe Arguments:")
+        for k, v in self.probe_args.__dict__.items():
+            if k != 'model_names':
+                print(f"{k}:\n{v}")
+        print("========================\n")
+        args_dict = {k: v for k, v in self.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}
+        self.logger_args = SimpleNamespace(**args_dict)
+        self._write_args()
+        print_done()
+
+    def _run_trainer(self):
+        print_message("Starting training process...")
+        # Gather settings
+        self.full_args.use_lora = self.settings_vars["use_lora"].get()
+        self.full_args.hybrid_probe = self.settings_vars["hybrid_probe"].get()
+        self.full_args.full_finetuning = self.settings_vars["full_finetuning"].get()
+        self.full_args.lora_r = self.settings_vars["lora_r"].get()
+        self.full_args.lora_alpha = self.settings_vars["lora_alpha"].get()
+        self.full_args.lora_dropout = self.settings_vars["lora_dropout"].get()
+        self.full_args.num_epochs = self.settings_vars["num_epochs"].get()
+        self.full_args.trainer_batch_size = self.settings_vars["probe_batch_size"].get()
+        self.full_args.gradient_accumulation_steps = self.settings_vars["probe_grad_accum"].get()
+        self.full_args.lr = self.settings_vars["lr"].get()
+        self.full_args.weight_decay = self.settings_vars["weight_decay"].get()
+        self.full_args.patience = self.settings_vars["patience"].get()
+        self.full_args.seed = self.settings_vars["seed"].get()
+
+        def background_run_trainer():
+            self.trainer_args = TrainerArguments(**self.full_args.__dict__)
+            args_dict = {k: v for k, v in self.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}
+            self.logger_args = SimpleNamespace(**args_dict)
+            self._write_args()
+
+            if self.full_args.full_finetuning:
+                self.run_full_finetuning()
+            elif self.full_args.hybrid_probe:
+                self.run_hybrid_probes()
+            else:
+                self.run_nn_probes()
+            print_done()
+                
+        self.run_in_background(background_run_trainer)
+
+    def _run_scikit(self):
+        print_message("Running scikit-learn models...")
+        # Gather settings for scikit
+        self.full_args.use_scikit = self.settings_vars["use_scikit"].get()
+        self.full_args.scikit_n_iter = self.settings_vars["scikit_n_iter"].get()
+        self.full_args.scikit_cv = self.settings_vars["scikit_cv"].get()
+        self.full_args.scikit_random_state = self.settings_vars["scikit_random_state"].get()
+        self.full_args.scikit_model_name = self.settings_vars["scikit_model_name"].get()
+        self.full_args.n_jobs = self.settings_vars["n_jobs"].get()
+
+        def background_run_scikit():
+            self.scikit_args = ScikitArguments(**self.full_args.__dict__)
+            args_dict = {k: v for k, v in self.full_args.__dict__.items() if k != 'all_seqs' and 'token' not in k.lower() and 'api' not in k.lower()}
+            self.logger_args = SimpleNamespace(**args_dict)
+            self._write_args()
+            
+            self.run_scikit_scheme()
+            print_done()
+            
+        self.run_in_background(background_run_scikit)
+
+    def _browse_replay_log(self):
+        filename = filedialog.askopenfilename(
+            title="Select Replay Log",
+            filetypes=(("Txt files", "*.txt"), ("All files", "*.*"))
+        )
+        if filename:
+            self.settings_vars["replay_path"].set(filename)
+
+    def _start_replay(self):
+        replay_path = self.settings_vars["replay_path"].get()
+        if not replay_path:
+            print_message("Please select a replay log file first")
+            return
+        
+        print_message("Starting replay from log file...")
+        
+        def background_replay():
+            from logger import LogReplayer
+            replayer = LogReplayer(replay_path)
+            replay_args = replayer.parse_log()
+            replay_args.replay_path = replay_path
+            
+            # Create a new MainProcess instance with replay_args
+            main = MainProcess(replay_args, GUI=False)
+            for k, v in main.full_args.__dict__.items():
+                print(f"{k}:\t{v}")
+            
+            # Run the replay on this MainProcess instance
+            replayer.run_replay(main)
+            print_done()
+        
+        self.run_in_background(background_replay)
+        
+    def _browse_results_file(self):
+        filename = filedialog.askopenfilename(
+            title="Select Results File",
+            filetypes=(("TSV files", "*.tsv"), ("All files", "*.*"))
+        )
+        if filename:
+            self.settings_vars["results_file"].set(filename)
+            # Set use_current_run to False since we're selecting a specific file
+            self.settings_vars["use_current_run"].set(False)
+    
+    def _generate_plots(self):
+        print_message("Generating visualization plots...")
+        
+        # Determine which results file to use
+        results_file = None
+        
+        if self.settings_vars["use_current_run"].get() and hasattr(self, 'random_id'):
+            # Use the current run's random ID
+            results_file = os.path.join(self.settings_vars["results_dir"].get(), f"{self.random_id}.tsv")
+            print_message(f"Using current run results: {results_file}")
+        elif self.settings_vars["results_file"].get():
+            # Use explicitly selected file
+            results_file = self.settings_vars["results_file"].get()
+            print_message(f"Using selected results file: {results_file}")
+        elif self.settings_vars["result_id"].get():
+            # Use the specified result ID
+            result_id = self.settings_vars["result_id"].get()
+            results_file = os.path.join(self.settings_vars["results_dir"].get(), f"{result_id}.tsv")
+            print_message(f"Using results file for ID {result_id}: {results_file}")
+        else:
+            print_message("No results file specified. Please enter a Result ID, browse for a file, or complete a run first.")
+            return
+        
+        # Check if the results file exists
+        if not os.path.exists(results_file):
+            print_message(f"Results file not found: {results_file}")
+            return
+        
+        # Get output directory
+        output_dir = self.settings_vars["viz_output_dir"].get()
+        def background_generate_plots():
+            # Call the plot generation function
+            print_message(f"Generating plots in {output_dir}...")
+            create_plots(results_file, output_dir)
+            print_message("Plots generated successfully!")
+            print_done()
+            
+        self.run_in_background(background_generate_plots)
+
+
+def main():
+    root = tk.Tk()
+    app = GUI(root)
+    print_title("Protify")
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    main()

data/src/protify/logger.py

@@ -0,0 +1,287 @@
+import logging
+import functools
+import json
+import csv
+import os
+import datetime
+import ast
+import random
+import string
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from utils import print_message
+
+
+def log_method_calls(func):
+    """Decorator to log each call of the decorated method."""
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        self.logger.info(f"Called method: {func.__name__}")
+        return func(self, *args, **kwargs)
+    return wrapper
+
+
+class MetricsLogger:
+    """
+    Logs method calls to a text file, and keeps a TSV-based matrix of metrics:
+      - Rows = dataset names
+      - Columns = model names
+      - Cells = JSON-encoded dictionaries of metrics
+    """
+
+    def __init__(self, args):
+        self.logger_args = args
+        self._section_break = '\n' + '=' * 55 + '\n'
+
+    def _start_file(self):
+        args = self.logger_args
+        self.log_dir = args.log_dir
+        self.results_dir = args.results_dir
+        os.makedirs(self.log_dir, exist_ok=True)
+        os.makedirs(self.results_dir, exist_ok=True)
+
+        # Generate random ID with date and 4-letter code
+        random_letters = ''.join(random.choices(string.ascii_uppercase, k=4))
+        date_str = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M')
+        self.random_id = f"{date_str}_{random_letters}"
+        
+        if args.replay_path is not None:
+            self.random_id = 'replay_' + args.replay_path.split('/')[-1].split('.')[0]
+        self.log_file = os.path.join(self.log_dir, f"{self.random_id}.txt")
+        self.results_file = os.path.join(self.results_dir, f"{self.random_id}.tsv")
+
+    def _minimial_logger(self):
+        # Set up a minimal logger
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.logger.setLevel(logging.INFO)
+
+        # Avoid adding multiple handlers if re-instantiated
+        if not self.logger.handlers:
+            handler = logging.FileHandler(self.log_file, mode='a')
+            handler.setLevel(logging.INFO)
+            # Simple formatter without duplicating date/time
+            formatter = logging.Formatter('%(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+        # TSV tracking
+        self.results_file = self.results_file
+        self.logger_data_tracking = {}  # { dataset_name: { model_name: metrics_dict } }
+
+    def _write_args(self):
+        with open(self.log_file, 'a') as f:
+            f.write(self._section_break)
+            for k, v in self.logger_args.__dict__.items():
+                if 'token' not in k.lower() and 'api' not in k.lower():
+                    f.write(f"{k}:\t{v}\n")
+            f.write(self._section_break)
+
+    def start_log_main(self):
+        self._start_file()
+
+        with open(self.log_file, 'w') as f:
+            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            if self.logger_args.replay_path is not None:
+                message = f'=== REPLAY OF {self.logger_args.replay_path} ===\n'
+                f.write(message)
+            header = f"=== Logging session started at {now} ===\n"
+            f.write(header)
+            self._write_args()
+
+        self._minimial_logger()
+
+    def start_log_gui(self):
+        self._start_file()
+        with open(self.log_file, 'w') as f:
+            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            if self.logger_args.replay_path is not None:
+                message = f'=== REPLAY OF {self.logger_args.replay_path} ===\n'
+                f.write(message)
+            header = f"=== Logging session started at {now} ===\n"
+            f.write(header)
+            f.write(self._section_break)
+        self._minimial_logger()
+
+    def load_tsv(self):
+        """Load existing TSV data into self.logger_data_tracking (row=dataset, col=model)."""
+        with open(self.results_file, 'r', newline='', encoding='utf-8') as f:
+            reader = csv.reader(f, delimiter='\t')
+            header = next(reader, None)
+            if not header:
+                return
+
+            model_names = header[1:]
+            for row in reader:
+                if row:
+                    ds = row[0]
+                    self.logger_data_tracking[ds] = {}
+                    for i, model in enumerate(model_names, start=1):
+                        cell_val = row[i].strip()
+                        if cell_val:
+                            try:
+                                self.logger_data_tracking[ds][model] = json.loads(cell_val)
+                            except json.JSONDecodeError:
+                                self.logger_data_tracking[ds][model] = {"_raw": cell_val}
+
+    def write_results(self):
+        # Get all unique datasets and models
+        datasets = sorted(self.logger_data_tracking.keys())
+        all_models = set()
+        for ds_data in self.logger_data_tracking.values():
+            all_models.update(ds_data.keys())
+        
+        # Calculate average eval_loss for each model
+        model_scores = {}
+        for model in all_models:
+            losses = []
+            for ds in datasets:
+                if (ds in self.logger_data_tracking and 
+                    model in self.logger_data_tracking[ds] and 
+                    'eval_loss' in self.logger_data_tracking[ds][model]):
+                    losses.append(self.logger_data_tracking[ds][model]['eval_loss'])
+            if losses:
+                model_scores[model] = sum(losses) / len(losses)
+            else:
+                model_scores[model] = float('inf')  # Models without eval_loss go last
+        
+        # Sort models by average eval_loss
+        model_names = sorted(model_scores.keys(), key=lambda m: model_scores[m])
+
+        with open(self.results_file, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f, delimiter='\t')
+            writer.writerow(["dataset"] + model_names)
+            for ds in datasets:
+                row = [ds]
+                for model in model_names:
+                    # Get metrics if they exist, otherwise empty dict
+                    metrics = self.logger_data_tracking.get(ds, {}).get(model, {})
+                    row.append(json.dumps(metrics))
+                writer.writerow(row)
+
+    def log_metrics(self, dataset, model, metrics_dict, split_name=None):
+        try:
+            # Remove time-related metrics
+            metrics_dict = {k: v for k, v in metrics_dict.items() 
+                           if 'time' not in k.lower() and 'second' not in k.lower()}
+            
+            # Log the metrics
+            if split_name is not None:
+                self.logger.info(f"Storing metrics for {dataset}/{model} ({split_name}): {metrics_dict}")
+            else:
+                self.logger.info(f"Storing metrics for {dataset}/{model}: {metrics_dict}")
+            
+            # Initialize nested dictionaries if they don't exist
+            if dataset not in self.logger_data_tracking:
+                self.logger_data_tracking[dataset] = {}
+            
+            # Store the metrics
+            self.logger_data_tracking[dataset][model] = metrics_dict
+            
+            # Write results after each update to ensure nothing is lost
+            self.write_results()
+            
+        except Exception as e:
+            self.logger.error(f"Error logging metrics for {dataset}/{model}: {str(e)}")
+
+    def end_log(self):
+        # Try multiple commands to get pip list
+        pip_commands = [
+            'python -m pip list',
+            'py -m pip list',
+            'pip list',
+            'pip3 list',
+            f'{sys.executable} -m pip list'  # Use current Python interpreter
+        ]
+        
+        pip_list = "Could not retrieve pip list"
+        for cmd in pip_commands:
+            try:
+                process = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+                if process.returncode == 0 and process.stdout.strip():
+                    pip_list = process.stdout.strip()
+                    break
+            except Exception:
+                continue
+
+        # Try to get nvidia-smi output, handle case where it's not available
+        try:
+            nvidia_info = os.popen('nvidia-smi').read().strip()
+        except:
+            nvidia_info = "nvidia-smi not available"
+        
+        # Get system info
+        import platform
+        system_info = {
+            'platform': platform.platform(),
+            'processor': platform.processor(),
+            'machine': platform.machine()
+        }
+        
+        # Get Python version and executable path
+        python_version = platform.python_version()
+        python_executable = sys.executable
+        
+        # Log all information with proper formatting
+        self.logger.info(self._section_break)
+        self.logger.info("System Information:")
+        self.logger.info(f"Python Version: {python_version}")
+        self.logger.info(f"Python Executable: {python_executable}")
+        for key, value in system_info.items():
+            self.logger.info(f"{key.title()}: {value}")
+        
+        self.logger.info("\nInstalled Packages:")
+        self.logger.info(pip_list)
+        
+        self.logger.info("\nGPU Information:")
+        self.logger.info(nvidia_info)
+        self.logger.info(self._section_break)
+
+
+class LogReplayer:
+    def __init__(self, log_file_path):
+        self.log_file = Path(log_file_path)
+        self.arguments = {}
+        self.method_calls = []
+
+    def parse_log(self):
+        """
+        Reads the log file line by line. Extracts:
+          1) Global arguments into self.arguments
+          2) Method calls into self.method_calls (in order)
+        """
+        if not self.log_file.exists():
+            raise FileNotFoundError(f"Log file not found: {self.log_file}")
+
+        with open(self.log_file, 'r') as file:
+            header = next(file)
+            for line in file:
+                if line.startswith('='):
+                    continue
+                elif line.startswith('INFO'):
+                    method = line.split(': ')[-1].strip()
+                    self.method_calls.append(method)
+                elif ':\t' in line:
+                    key, value = line.split(':\t')
+                    key, value = key.strip(), value.strip()
+                    try:
+                        value = ast.literal_eval(value)
+                    except (ValueError, SyntaxError):
+                        pass
+                    self.arguments[key] = value
+
+        return SimpleNamespace(**self.arguments)
+
+    def run_replay(self, target_obj):
+        """
+        Replays the collected method calls on `target_obj`.
+        `target_obj` is an instance of the class/script that we want to replay.
+        """
+        for method in self.method_calls:
+            print_message(f"Replaying call to: {method}()")
+            func = getattr(target_obj, method, None)
+            if not func:
+                print_message(f"Warning: {method} not found on target object.")
+                continue
+            func()