{ "cells": [ { "cell_type": "markdown", "id": "cell-00", "metadata": {}, "source": [ "# Finetuning AlphaGenome's encoder on MPRA data\n", "\n", "This notebook demos how to train an MLP regression head on a **frozen** AlphaGenome encoder for one LentiMPRA cell line (HepG2) from\n", "[Agarwal et al. 2025](https://www.nature.com/articles/s41586-024-08430-9).\n", "\n", "**Why encoder-only?**\n", "MPRA constructs are short (~200–300 bp). The CNN encoder alone handles arbitrary short sequences and produces\n", "contextual 1536-dimensional embeddings at 128 bp resolution. This approach leverages the rich sequence representations learned by large-scale generalist models while adapting them to specific regulatory tasks through task-specific prediction heads.\n", "\n", "**Steps:**\n", "1. Install dependencies\n", "2. Download HepG2 LentiMPRA data\n", "3. Define dataset, head, and training utilities\n", "4. Configure hyperparameters\n", "5. Load pretrained AlphaGenome backbone and freeze it\n", "6. Create `MPRAHead` (LayerNorm → flatten → MLP → scalar output)\n", "7. Build datasets and DataLoaders\n", "8. Train (encoder-only forward, only head params updated)\n", "9. Plot loss / Pearson curves and evaluate on test set" ] }, { "cell_type": "markdown", "id": "cell-01", "metadata": {}, "source": [ "## 1. Install dependencies" ] }, { "cell_type": "code", "execution_count": 1, "id": "cell-03", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PyTorch: 2.10.0+cu128\n", "CUDA available: True\n", "GPU: NVIDIA H100 80GB HBM3\n" ] } ], "source": [ "import torch\n", "\n", "print(f\"PyTorch: {torch.__version__}\")\n", "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", "if torch.cuda.is_available(): print(f\"GPU: {torch.cuda.get_device_name(0)}\")" ] }, { "cell_type": "markdown", "id": "cell-04", "metadata": {}, "source": [ "## 2. Download HepG2 LentiMPRA data\n", "\n", "Training data (HepG2 LentiMPRA) is downloaded from\n", "[human_legnet](https://github.com/autosome-ru/human_legnet) (`datasets/original/HepG2.tsv`).\n", "The TSV contains one row per unique MPRA insert with columns:\n", "- `seq`: DNA sequence of the regulatory element\n", "- `fold`: cross-validation fold (1–10)\n", "- `rev`: strand (0 = forward; we keep forward only)\n", "- `mean_value`: mean log-scale activity score across replicates" ] }, { "cell_type": "code", "execution_count": 2, "id": "cell-05", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloaded to ./data/legnet_lentimpra/HepG2.tsv\n", "Total forward-strand samples : 122,926\n", "Training samples (folds 2-9) : 98,336\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
seq_idseqmean_valuefoldrev
0DNasePeakNoPromoter1AGGACCGGATCAACTCCTAACCCTAACCCTAACCCTAACCCTAACC...-0.67520
1DNasePeakNoPromoter1_Reversed:AGGACCGGATCAACTCGTTCTCCTCAGCACAGACCCGGAGAGCACC...-0.27420
2DNasePeakNoPromoter10AGGACCGGATCAACTTGTTTCTTAGGAAAGGCGGCCAACCCAGGGT...0.908100
3DNasePeakNoPromoter10_Reversed:AGGACCGGATCAACTGGTTAGAGCTCAAAGGTCACTCCGATGACAC...0.276100
4DNasePeakNoPromoter100AGGACCGGATCAACTATTACTCACACAAGACACACATTGTCTGCCG...1.29590
\n", "
" ], "text/plain": [ " seq_id \\\n", "0 DNasePeakNoPromoter1 \n", "1 DNasePeakNoPromoter1_Reversed: \n", "2 DNasePeakNoPromoter10 \n", "3 DNasePeakNoPromoter10_Reversed: \n", "4 DNasePeakNoPromoter100 \n", "\n", " seq mean_value fold rev \n", "0 AGGACCGGATCAACTCCTAACCCTAACCCTAACCCTAACCCTAACC... -0.675 2 0 \n", "1 AGGACCGGATCAACTCGTTCTCCTCAGCACAGACCCGGAGAGCACC... -0.274 2 0 \n", "2 AGGACCGGATCAACTTGTTTCTTAGGAAAGGCGGCCAACCCAGGGT... 0.908 10 0 \n", "3 AGGACCGGATCAACTGGTTAGAGCTCAAAGGTCACTCCGATGACAC... 0.276 10 0 \n", "4 AGGACCGGATCAACTATTACTCACACAAGACACACATTGTCTGCCG... 1.295 9 0 " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "import urllib.request\n", "import pandas as pd\n", "\n", "DATA_DIR = \"./data/legnet_lentimpra\"\n", "os.makedirs(DATA_DIR, exist_ok=True)\n", "\n", "HEPG2_URL = \"https://raw.githubusercontent.com/autosome-ru/human_legnet/main/datasets/original/HepG2.tsv\"\n", "hepg2_path = os.path.join(DATA_DIR, \"HepG2.tsv\")\n", "urllib.request.urlretrieve(HEPG2_URL, hepg2_path)\n", "print(f\"Downloaded to {hepg2_path}\")\n", "\n", "# Preview the data\n", "df_all = pd.read_csv(hepg2_path, sep=\"\\t\")\n", "df_fwd = df_all[df_all[\"rev\"] == 0]\n", "train_df = df_fwd[df_fwd[\"fold\"].isin([2,3,4,5,6,7,8,9])]\n", "print(f\"Total forward-strand samples : {len(df_fwd):,}\")\n", "print(f\"Training samples (folds 2-9) : {len(train_df):,}\")\n", "df_fwd.head()" ] }, { "cell_type": "markdown", "id": "cell-06", "metadata": {}, "source": [ "## 3. Custom classes\n", "\n", "The cells below define custom dataset and head classes which we use to define our MPRA model:\n", "- **`LentiMPRADataset`** — PyTorch `Dataset` that assembles MPRA constructs\n", " (seq + promoter + barcode), one-hot encodes them, and optionally applies\n", " reverse-complement and random-shift augmentations.\n", "- **`MPRAHead`** — `nn.Module` MLP regression head that takes raw CNN encoder\n", " output `(B, n_pos, 1536)` and returns scalar activity predictions `(B,)`.\n", "- **`train_epoch`** and **`evaluate`** — lightweight training/evaluation loops\n", " using MSE loss and Pearson r." ] }, { "cell_type": "code", "execution_count": 3, "id": "cell-07", "metadata": {}, "outputs": [], "source": [ "from __future__ import annotations\n", "\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "from contextlib import nullcontext\n", "from torch import Tensor\n", "from torch.utils.data import Dataset, DataLoader\n", "from tqdm import tqdm\n", "\n", "from alphagenome_pytorch.extensions.finetuning.utils import sequence_to_onehot\n", "from alphagenome_pytorch.metrics import pearson_r\n", "\n", "\n", "class LentiMPRADataset(Dataset):\n", " \"\"\"PyTorch Dataset for LentiMPRA data (Agarwal et al., 2025).\n", "\n", " Assembles the full construct (seq + promoter + barcode), one-hot encodes it,\n", " pads or trims to ``sequence_length``, and optionally applies augmentations.\n", "\n", " Returns (seq_onehot, target) tuples where:\n", " seq_onehot : float32 tensor of shape (sequence_length, 4)\n", " target : float32 scalar (log-scale MPRA activity)\n", " \"\"\"\n", "\n", " PROMOTER_SEQ = \"TCCATTATATACCCTCTAGTGTCGGTTCACGCAATG\" # 36 bp\n", " RAND_BARCODE = \"AGAGACTGAGGCCAC\" # 15 bp\n", "\n", " FOLD_SPLITS: dict[str, list[int]] = {\n", " \"train\": [2, 3, 4, 5, 6, 7, 8, 9],\n", " \"val\": [1],\n", " \"test\": [10],\n", " }\n", "\n", " def __init__(\n", " self,\n", " data_dir: str,\n", " cell_type: str = \"HepG2\",\n", " split: str = \"train\",\n", " sequence_length: int = 256,\n", " reverse_complement: bool = False,\n", " rc_prob: float = 0.5,\n", " random_shift: bool = False,\n", " shift_prob: float = 0.5,\n", " max_shift: int = 15,\n", " subset_frac: float = 1.0,\n", " seed: int = 42,\n", " ) -> None:\n", " assert split in (\"train\", \"val\", \"test\"), f\"Unknown split: {split!r}\"\n", " assert cell_type in (\"HepG2\", \"K562\", \"WTC11\"), f\"Unknown cell_type: {cell_type!r}\"\n", "\n", " self.sequence_length = sequence_length\n", " self.reverse_complement = reverse_complement\n", " self.rc_prob = rc_prob\n", " self.random_shift = random_shift\n", " self.shift_prob = shift_prob\n", " self.max_shift = max_shift\n", " self._rng = np.random.default_rng(seed)\n", "\n", " # Load TSV and filter\n", " df = pd.read_csv(os.path.join(data_dir, f\"{cell_type}.tsv\"), sep=\"\\t\")\n", " df = df[df[\"rev\"] == 0] # forward strand only\n", " df = df[df[\"fold\"].isin(self.FOLD_SPLITS[split])].reset_index(drop=True)\n", "\n", " if subset_frac < 1.0:\n", " df = df.sample(frac=subset_frac, random_state=seed).reset_index(drop=True)\n", "\n", " self.sequences: list[str] = df[\"seq\"].tolist()\n", " self.targets: np.ndarray = df[\"mean_value\"].values.astype(np.float32)\n", " print(f\"Loaded {len(self.sequences):,} {split} samples ({cell_type})\")\n", "\n", " def _build_construct(self, seq: str) -> str:\n", " return seq + self.PROMOTER_SEQ + self.RAND_BARCODE\n", "\n", " def _pad_or_trim(self, onehot: np.ndarray) -> np.ndarray:\n", " L = onehot.shape[0]\n", " if L < self.sequence_length:\n", " pad = np.zeros((self.sequence_length - L, 4), dtype=np.float32)\n", " return np.concatenate([onehot, pad], axis=0)\n", " return onehot[: self.sequence_length]\n", "\n", " def _apply_reverse_complement(self, onehot: np.ndarray) -> np.ndarray:\n", " \"\"\"Reverse the sequence and swap A↔T, C↔G (columns 0↔3, 1↔2).\"\"\"\n", " return onehot[::-1, :][:, [3, 2, 1, 0]].copy()\n", "\n", " def __len__(self) -> int:\n", " return len(self.sequences)\n", "\n", " def __getitem__(self, idx: int) -> tuple[Tensor, Tensor]:\n", " construct = self._build_construct(self.sequences[idx])\n", " target = self.targets[idx]\n", "\n", " # One-hot encode (uint8 → float32)\n", " onehot = sequence_to_onehot(construct).astype(np.float32)\n", "\n", " # Optional: random shift augmentation\n", " if self.random_shift and self._rng.random() < self.shift_prob:\n", " shift = int(self._rng.integers(-self.max_shift, self.max_shift + 1))\n", " onehot = np.roll(onehot, shift, axis=0)\n", "\n", " # Pad / trim to fixed length\n", " onehot = self._pad_or_trim(onehot)\n", "\n", " # Optional reverse complement augmentation\n", " if self.reverse_complement and self._rng.random() < self.rc_prob:\n", " onehot = self._apply_reverse_complement(onehot)\n", "\n", " return torch.from_numpy(onehot), torch.tensor(target)" ] }, { "cell_type": "code", "execution_count": 4, "id": "1729b955-1f3b-499c-a1ab-a5a703abc78d", "metadata": {}, "outputs": [], "source": [ "class MPRAHead(nn.Module):\n", " \"\"\"MLP head for MPRA activity score regression from encoder-only features.\n", "\n", " Accepts raw CNN encoder output ``(B, n_positions, encoder_dim)`` and predicts\n", " a scalar activity score per sequence.\n", "\n", " Architecture::\n", " encoder_output (B, n_pos, 1536)\n", " → LayerNorm\n", " → flatten (B, n_pos * 1536)\n", " → Linear(n_pos * 1536, hidden_size) + ReLU + Dropout\n", " → Linear(hidden_size, 1)\n", " → squeeze → (B,)\n", " \"\"\"\n", "\n", " ENCODER_DIM: int = 1536 # AlphaGenome encoder output channels\n", "\n", " def __init__(\n", " self,\n", " n_positions: int,\n", " hidden_size: int = 1024,\n", " dropout: float = 0.1,\n", " ) -> None:\n", " super().__init__()\n", " flatten_dim = n_positions * self.ENCODER_DIM\n", " self.norm = nn.LayerNorm(self.ENCODER_DIM)\n", " self.fc1 = nn.Linear(flatten_dim, hidden_size)\n", " self.dropout = nn.Dropout(dropout)\n", " self.fc2 = nn.Linear(hidden_size, 1)\n", "\n", " def forward(self, encoder_output: Tensor) -> Tensor:\n", " \"\"\"Forward pass.\n", "\n", " Args:\n", " encoder_output: Raw CNN encoder features, shape (B, n_positions, ENCODER_DIM).\n", "\n", " Returns:\n", " Predicted activity scores, shape (B,).\n", " \"\"\"\n", " x = self.norm(encoder_output) # (B, n_pos, ENCODER_DIM)\n", " x = x.flatten(1) # (B, n_pos * ENCODER_DIM)\n", " x = F.relu(self.fc1(x)) # (B, hidden_size)\n", " x = self.dropout(x)\n", " x = self.fc2(x) # (B, 1)\n", " return x.squeeze(-1) # (B,)" ] }, { "cell_type": "markdown", "id": "62aabbed-2258-48da-b5f9-b79a2cc1b4a5", "metadata": {}, "source": [ "We also define utilities to train and evaluate the MPRA model." ] }, { "cell_type": "code", "execution_count": 5, "id": "ba878bfd-1e06-4ac9-89ac-50a969db0d1e", "metadata": {}, "outputs": [], "source": [ "def train_epoch(\n", " model: nn.Module,\n", " head: MPRAHead,\n", " loader: DataLoader,\n", " optimizer: torch.optim.Optimizer,\n", " device: torch.device,\n", " use_amp: bool = True,\n", ") -> tuple[float, float]:\n", " \"\"\"Train MPRAHead for one epoch (backbone frozen, encoder-only forward).\n", "\n", " The backbone is always kept in eval mode (all its parameters are frozen).\n", " Only ``head`` parameters receive gradient updates.\n", "\n", " Returns:\n", " (avg_mse_loss, pearson_r) over the epoch.\n", " \"\"\"\n", " model.eval() \n", " head.train()\n", "\n", " amp_ctx = (\n", " torch.autocast(device_type=\"cuda\", dtype=torch.bfloat16)\n", " if use_amp and device.type == \"cuda\"\n", " else nullcontext()\n", " )\n", "\n", " total_loss = 0.0\n", " all_preds: list[Tensor] = []\n", " all_targets: list[Tensor] = []\n", "\n", " pbar = tqdm(loader, desc=\" train\", leave=False)\n", " for sequences, targets in pbar:\n", " sequences = sequences.to(device) # (B, L, 4)\n", " targets = targets.to(device).float() # (B,)\n", " organism_idx = torch.zeros(\n", " sequences.shape[0], dtype=torch.long, device=device\n", " )\n", "\n", " # Frozen encoder forward\n", " with torch.no_grad():\n", " with amp_ctx:\n", " enc_out = model(\n", " sequences, organism_idx, encoder_only=True\n", " )[\"encoder_output\"] # (B, n_pos, 1536)\n", " enc_out = enc_out.detach()\n", "\n", " # Head forward + MSE loss\n", " with amp_ctx:\n", " preds = head(enc_out) # (B,)\n", " loss = F.mse_loss(preds.float(), targets.float())\n", "\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " total_loss += loss.item()\n", " all_preds.append(preds.detach().float().cpu())\n", " all_targets.append(targets.float().cpu())\n", " pbar.set_postfix({\"mse\": f\"{loss.item():.4f}\"})\n", "\n", " preds_cat = torch.cat(all_preds)\n", " targets_cat = torch.cat(all_targets)\n", " return total_loss / len(loader), pearson_r(preds_cat, targets_cat)\n", "\n", "\n", "@torch.no_grad()\n", "def evaluate(\n", " model: nn.Module,\n", " head: MPRAHead,\n", " loader: DataLoader,\n", " device: torch.device,\n", " use_amp: bool = True,\n", ") -> tuple[float, float]:\n", " \"\"\"Evaluate MPRAHead on a DataLoader.\n", "\n", " Returns:\n", " (avg_mse_loss, pearson_r).\n", " \"\"\"\n", " model.eval()\n", " head.eval()\n", "\n", " amp_ctx = (\n", " torch.autocast(device_type=\"cuda\", dtype=torch.bfloat16)\n", " if use_amp and device.type == \"cuda\"\n", " else nullcontext()\n", " )\n", "\n", " total_loss = 0.0\n", " all_preds: list[Tensor] = []\n", " all_targets: list[Tensor] = []\n", "\n", " for sequences, targets in loader:\n", " sequences = sequences.to(device)\n", " targets = targets.to(device).float()\n", " organism_idx = torch.zeros(\n", " sequences.shape[0], dtype=torch.long, device=device\n", " )\n", "\n", " with amp_ctx:\n", " enc_out = model(\n", " sequences, organism_idx, encoder_only=True\n", " )[\"encoder_output\"] # (B, n_pos, 1536)\n", " preds = head(enc_out) # (B,)\n", " loss = F.mse_loss(preds.float(), targets.float())\n", " \n", " total_loss += loss.item()\n", " all_preds.append(preds.float().cpu())\n", " all_targets.append(targets.float().cpu())\n", "\n", " preds_cat = torch.cat(all_preds)\n", " targets_cat = torch.cat(all_targets)\n", " return total_loss / len(loader), pearson_r(preds_cat, targets_cat)" ] }, { "cell_type": "markdown", "id": "cell-08", "metadata": {}, "source": [ "## 4. Configuration\n", "\n", "Define the following key settings for training:\n", "- `SEQUENCE_LENGTH = 256` — All constructs are padded/trimmed to 256 bp. This gives **2 encoder positions**\n", " which are flattened to 2 × 1536 = 3072 features fed into the MLP.\n", "- `PRETRAINED_WEIGHTS` — Path to the converted AlphaGenome PyTorch checkpoint.\n", " Run `scripts/convert_weights.py` once to produce this file from the original JAX weights." ] }, { "cell_type": "code", "execution_count": 6, "id": "cell-09", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Configuration:\n", " PRETRAINED_WEIGHTS : finetune_files/weights/fold_0_weights.pth\n", " CELL_TYPE : HepG2\n", " SEQUENCE_LENGTH : 256 bp → 2 encoder positions\n", " HIDDEN_SIZE : 1024\n", " SUBSET_FRAC : 1.0\n", " BATCH_SIZE : 32\n", " NUM_EPOCHS : 10\n", " LEARNING_RATE : 0.001\n", " DEVICE : cuda\n" ] } ], "source": [ "from pathlib import Path\n", "\n", "PRETRAINED_WEIGHTS = \"finetune_files/weights/fold_0_weights.pth\" \n", "DATA_DIR = \"./data/legnet_lentimpra\"\n", "CELL_TYPE = \"HepG2\"\n", "SEQUENCE_LENGTH = 256\n", "N_ENC_POSITIONS = SEQUENCE_LENGTH // 128 \n", "HIDDEN_SIZE = 1024\n", "DROPOUT = 0.1\n", "SUBSET_FRAC = 1.0\n", "BATCH_SIZE = 32\n", "NUM_EPOCHS = 10 \n", "LEARNING_RATE = 1e-3\n", "WEIGHT_DECAY = 0.0\n", "EARLY_STOPPING_PATIENCE = 5\n", "CHECKPOINT_DIR = Path(\"./checkpoints_mpra\")\n", "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)\n", "\n", "print(\"Configuration:\")\n", "print(f\" PRETRAINED_WEIGHTS : {PRETRAINED_WEIGHTS}\")\n", "print(f\" CELL_TYPE : {CELL_TYPE}\")\n", "print(f\" SEQUENCE_LENGTH : {SEQUENCE_LENGTH} bp → {N_ENC_POSITIONS} encoder positions\")\n", "print(f\" HIDDEN_SIZE : {HIDDEN_SIZE}\")\n", "print(f\" SUBSET_FRAC : {SUBSET_FRAC}\")\n", "print(f\" BATCH_SIZE : {BATCH_SIZE}\")\n", "print(f\" NUM_EPOCHS : {NUM_EPOCHS}\")\n", "print(f\" LEARNING_RATE : {LEARNING_RATE}\")\n", "print(f\" DEVICE : {DEVICE}\")" ] }, { "cell_type": "markdown", "id": "cell-10", "metadata": {}, "source": [ "## 5. Load pretrained model and freeze backbone\n", "\n", "We load the AlphaGenome pretrained weights (trunk only, heads excluded), freeze every\n", "backbone parameter, and attach a fresh `MPRAHead`. Only the head is trained." ] }, { "cell_type": "code", "execution_count": 7, "id": "cell-11", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loading pretrained weights from finetune_files/weights/fold_0_weights.pth ...\n", "Backbone loaded and frozen.\n", " Backbone parameters: 403,918,983 (none trainable)\n" ] } ], "source": [ "from alphagenome_pytorch import AlphaGenome\n", "from alphagenome_pytorch.extensions.finetuning.transfer import (\n", " load_trunk,\n", " remove_all_heads,\n", ")\n", "\n", "print(f\"Loading pretrained weights from {PRETRAINED_WEIGHTS} ...\")\n", "model = AlphaGenome()\n", "model = load_trunk(model, PRETRAINED_WEIGHTS, exclude_heads=True)\n", "for param in model.parameters():\n", " param.requires_grad = False\n", "\n", "# Remove original multi-task heads (they are not needed for MPRA regression)\n", "model = remove_all_heads(model)\n", "model = model.to(DEVICE)\n", "model.eval()\n", "\n", "n_backbone = sum(p.numel() for p in model.parameters())\n", "print(f\"Backbone loaded and frozen.\")\n", "print(f\" Backbone parameters: {n_backbone:,} (none trainable)\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "cell-12", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MPRAHead created.\n", " Trainable (head) : 3,150,849\n", " Frozen (backbone) : 403,918,983\n", " Total parameters : 407,069,832\n", " Trainable fraction : 0.7740%\n", "\n", "Head architecture:\n", "MPRAHead(\n", " (norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", " (fc1): Linear(in_features=3072, out_features=1024, bias=True)\n", " (dropout): Dropout(p=0.1, inplace=False)\n", " (fc2): Linear(in_features=1024, out_features=1, bias=True)\n", ")\n" ] } ], "source": [ "# Instantiate MPRAHead and move to device\n", "head = MPRAHead(\n", " n_positions=N_ENC_POSITIONS,\n", " hidden_size=HIDDEN_SIZE,\n", " dropout=DROPOUT,\n", ").to(DEVICE)\n", "\n", "n_trainable = sum(p.numel() for p in head.parameters())\n", "n_total = sum(p.numel() for p in model.parameters()) + n_trainable\n", "\n", "print(f\"MPRAHead created.\")\n", "print(f\" Trainable (head) : {n_trainable:,}\")\n", "print(f\" Frozen (backbone) : {sum(p.numel() for p in model.parameters()):,}\")\n", "print(f\" Total parameters : {n_total:,}\")\n", "print(f\" Trainable fraction : {100 * n_trainable / n_total:.4f}%\")\n", "print()\n", "print(\"Head architecture:\")\n", "print(head)" ] }, { "cell_type": "markdown", "id": "cell-13", "metadata": {}, "source": [ "## 6. Datasets and DataLoaders\n", "\n", "Train the MPRA head on folds 2–9 with reverse-complement and random-shift augmentations. Validate on fold 1 and\n", "test on held-out fold 10." ] }, { "cell_type": "code", "execution_count": 9, "id": "cell-14", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded 98,336 train samples (HepG2)\n", "Loaded 12,292 val samples (HepG2)\n", "Loaded 12,298 test samples (HepG2)\n", "\n", "Train : 98,336 | Val : 12,292 | Test : 12,298\n" ] } ], "source": [ "train_dataset = LentiMPRADataset(\n", " data_dir=DATA_DIR, cell_type=CELL_TYPE, split=\"train\",\n", " sequence_length=SEQUENCE_LENGTH,\n", " reverse_complement=True, rc_prob=0.5,\n", " random_shift=True, shift_prob=0.5, max_shift=15,\n", " subset_frac=SUBSET_FRAC,\n", ")\n", "val_dataset = LentiMPRADataset(\n", " data_dir=DATA_DIR, cell_type=CELL_TYPE, split=\"val\",\n", " sequence_length=SEQUENCE_LENGTH,\n", " subset_frac=SUBSET_FRAC,\n", ")\n", "test_dataset = LentiMPRADataset(\n", " data_dir=DATA_DIR, cell_type=CELL_TYPE, split=\"test\",\n", " sequence_length=SEQUENCE_LENGTH,\n", " subset_frac=SUBSET_FRAC,\n", ")\n", "\n", "print(f\"\\nTrain : {len(train_dataset):,} | Val : {len(val_dataset):,} | Test : {len(test_dataset):,}\")" ] }, { "cell_type": "code", "execution_count": 10, "id": "cell-15", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Sample shapes:\n", " seq_onehot : (256, 4) (sequence_length=256, 4 bases)\n", " target : -0.6750 (log-scale activity)\n", "Encoder output shape: (1, 2, 1536)\n", " Expected: (1, 2, 1536) [batch=1, 256bp ÷ 128 = 2 positions, dim=1536]\n" ] } ], "source": [ "# Sanity check: run one sequence through the frozen encoder and verify output shape\n", "seq_ex, tgt_ex = train_dataset[0]\n", "print(f\"\\nSample shapes:\")\n", "print(f\" seq_onehot : {tuple(seq_ex.shape)} (sequence_length=256, 4 bases)\")\n", "print(f\" target : {tgt_ex.item():.4f} (log-scale activity)\")\n", "\n", "with torch.no_grad():\n", " seq_tmp = seq_ex.unsqueeze(0).to(DEVICE) # (1, 256, 4)\n", " org_tmp = torch.zeros(1, dtype=torch.long, device=DEVICE)\n", " enc_tmp = model(seq_tmp, org_tmp, encoder_only=True)[\"encoder_output\"]\n", "\n", "print(f\"Encoder output shape: {tuple(enc_tmp.shape)}\")\n", "print(f\" Expected: (1, {N_ENC_POSITIONS}, 1536) \"\n", " f\"[batch=1, {SEQUENCE_LENGTH}bp ÷ 128 = {N_ENC_POSITIONS} positions, dim=1536]\")" ] }, { "cell_type": "code", "execution_count": 11, "id": "cell-16", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train batches : 3,073\n", "Val batches : 385\n", "Test batches : 385\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/scratch/m000097/abuen/programs/conda/envs/ag-new/lib/python3.12/site-packages/torch/utils/data/dataloader.py:424: UserWarning: This DataLoader will create 2 worker processes in total. Our suggested max number of worker in current system is 1, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", " self.check_worker_number_rationality()\n" ] } ], "source": [ "train_loader = DataLoader(\n", " train_dataset, batch_size=BATCH_SIZE, shuffle=True,\n", " num_workers=2, pin_memory=True,\n", ")\n", "val_loader = DataLoader(\n", " val_dataset, batch_size=BATCH_SIZE, shuffle=False,\n", " num_workers=2, pin_memory=True,\n", ")\n", "test_loader = DataLoader(\n", " test_dataset, batch_size=BATCH_SIZE, shuffle=False,\n", " num_workers=2, pin_memory=True,\n", ")\n", "\n", "print(f\"Train batches : {len(train_loader):,}\")\n", "print(f\"Val batches : {len(val_loader):,}\")\n", "print(f\"Test batches : {len(test_loader):,}\")" ] }, { "cell_type": "markdown", "id": "cell-17", "metadata": {}, "source": [ "## 7. Optimizer and scheduler" ] }, { "cell_type": "code", "execution_count": 12, "id": "cell-18", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Optimizer : Adam (lr=0.001, wd=0.0)\n", "Scheduler : cosine decay with 3073 warmup steps\n", "Total steps: 30,730 (3073 steps × 10 epochs)\n" ] } ], "source": [ "from alphagenome_pytorch.extensions.finetuning.training import create_lr_scheduler\n", "\n", "# Optimize only the head parameters; backbone is fully frozen\n", "optimizer = torch.optim.Adam(\n", " head.parameters(),\n", " lr=LEARNING_RATE,\n", " weight_decay=WEIGHT_DECAY,\n", ")\n", "\n", "# Cosine LR schedule with a 1-epoch linear warmup\n", "steps_per_epoch = len(train_loader)\n", "total_steps = NUM_EPOCHS * steps_per_epoch\n", "warmup_steps = steps_per_epoch # 1 epoch warmup\n", "\n", "scheduler = create_lr_scheduler(\n", " optimizer,\n", " warmup_steps=warmup_steps,\n", " total_steps=total_steps,\n", " schedule=\"cosine\",\n", ")\n", "\n", "print(f\"Optimizer : Adam (lr={LEARNING_RATE}, wd={WEIGHT_DECAY})\")\n", "print(f\"Scheduler : cosine decay with {warmup_steps} warmup steps\")\n", "print(f\"Total steps: {total_steps:,} ({steps_per_epoch} steps × {NUM_EPOCHS} epochs)\")" ] }, { "cell_type": "markdown", "id": "cell-19", "metadata": {}, "source": [ "## 8. Train\n", "\n", "We are ready to train the model! The following are run during each training step:\n", "1. **Encoder forward** — run `model(..., encoder_only=True)` under `torch.no_grad()` to\n", " extract CNN features `(B, 2, 1536)`. Detach from the computation graph.\n", "2. **Head forward** — pass detached features through `MPRAHead` → scalar predictions `(B,)`.\n", "3. **Loss** — MSE between predictions and log-scale activity targets.\n", "4. **Backward + step** — update only `MPRAHead` parameters.\n", "\n", "Validation Pearson r is computed over the full validation set at the end of each epoch.\n", "The best checkpoint (lowest val MSE) is saved to `CHECKPOINT_DIR`." ] }, { "cell_type": "code", "execution_count": 13, "id": "cell-20", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting training: 10 epochs, batch size 32\n", "Backbone: frozen (encoder-only forward, no gradients)\n", "Head: MPRAHead (3,150,849 parameters)\n", "============================================================\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " train: 0%| | 0/3073 [00:00= EARLY_STOPPING_PATIENCE:\n", " print(f\"Early stopping at epoch {epoch} (no improvement for {EARLY_STOPPING_PATIENCE} epochs).\")\n", " break\n", "\n", "print()\n", "print(\"=\" * 60)\n", "print(f\"Training complete!\")\n", "print(f\" Best val MSE : {best_val_loss:.6f}\")\n", "print(f\" Best val Pearson : {max(history['val_pearson']):.4f}\")\n", "print(f\" Checkpoint saved : {CHECKPOINT_DIR / 'best_head.pt'}\")" ] }, { "cell_type": "markdown", "id": "cell-21", "metadata": {}, "source": [ "## 9. Plot training curves" ] }, { "cell_type": "code", "execution_count": 14, "id": "cell-22", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Plot saved to checkpoints_mpra/training_curves.png\n" ] } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "epochs = list(range(1, len(history[\"train_loss\"]) + 1))\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(11, 4))\n", "fig.suptitle(f\"Encoder-only MPRA Fine-tuning ({CELL_TYPE}, SUBSET_FRAC={SUBSET_FRAC})\", fontsize=13)\n", "\n", "# ── MSE loss ─────────────────────────────────────────────────────────────────\n", "ax = axes[0]\n", "ax.plot(epochs, history[\"train_loss\"], marker=\"o\", label=\"Train MSE\", color=\"steelblue\")\n", "ax.plot(epochs, history[\"val_loss\"], marker=\"s\", label=\"Val MSE\", color=\"tomato\")\n", "ax.set_xlabel(\"Epoch\")\n", "ax.set_ylabel(\"MSE Loss\")\n", "ax.set_title(\"MSE Loss\")\n", "ax.legend()\n", "ax.grid(True, alpha=0.3)\n", "\n", "# ── Pearson r ─────────────────────────────────────────────────────────────────\n", "ax = axes[1]\n", "ax.plot(epochs, history[\"train_pearson\"], marker=\"o\", label=\"Train Pearson r\", color=\"steelblue\")\n", "ax.plot(epochs, history[\"val_pearson\"], marker=\"s\", label=\"Val Pearson r\", color=\"tomato\")\n", "ax.plot(epochs, history[\"test_pearson\"], marker=\"^\", label=\"Test Pearson r\", color=\"seagreen\",\n", " linestyle=\"--\", alpha=0.8)\n", "ax.set_xlabel(\"Epoch\")\n", "ax.set_ylabel(\"Pearson r\")\n", "ax.set_title(\"Pearson Correlation\")\n", "ax.legend()\n", "ax.grid(True, alpha=0.3)\n", "\n", "plt.tight_layout()\n", "plt.savefig(CHECKPOINT_DIR / \"training_curves.png\", dpi=150)\n", "plt.show()\n", "\n", "print(f\"Plot saved to {CHECKPOINT_DIR / 'training_curves.png'}\")" ] }, { "cell_type": "markdown", "id": "cell-23", "metadata": {}, "source": [ "## 10. Final evaluation on the test set\n", "\n", "Load the best checkpoint and evaluate on held-out fold 10." ] }, { "cell_type": "code", "execution_count": 15, "id": "cell-24", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded best checkpoint from epoch 10\n", " Checkpoint val MSE : 0.195261\n", " Checkpoint val Pearson : 0.8210\n", "\n", "==================================================\n", "Test set (fold 10) results:\n", " MSE : 0.198946\n", " Pearson : 0.8211\n", "==================================================\n" ] } ], "source": [ "# Load best checkpoint\n", "ckpt = torch.load(CHECKPOINT_DIR / \"best_head.pt\", map_location=DEVICE, weights_only=True)\n", "head.load_state_dict(ckpt[\"head\"])\n", "print(f\"Loaded best checkpoint from epoch {ckpt['epoch']}\")\n", "print(f\" Checkpoint val MSE : {ckpt['val_loss']:.6f}\")\n", "print(f\" Checkpoint val Pearson : {ckpt['val_pearson']:.4f}\")\n", "\n", "# Evaluate on test set (fold 10, held out during training)\n", "test_loss, test_pearson = evaluate(\n", " model=model, head=head, loader=test_loader, device=DEVICE,\n", ")\n", "print()\n", "print(\"=\" * 50)\n", "print(f\"Test set (fold 10) results:\")\n", "print(f\" MSE : {test_loss:.6f}\")\n", "print(f\" Pearson : {test_pearson:.4f}\")\n", "print(\"=\" * 50)" ] }, { "cell_type": "code", "execution_count": 16, "id": "cell-25", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test Pearson r : 0.8211\n", "Test Spearman r : 0.8038\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Scatter saved to checkpoints_mpra/test_scatter.png\n" ] } ], "source": [ "# Scatter plot: predicted vs. ground-truth activity on the test set\n", "import numpy as np\n", "from scipy.stats import pearsonr, spearmanr\n", "\n", "all_preds_test, all_tgts_test = [], []\n", "\n", "model.eval()\n", "head.eval()\n", "with torch.no_grad():\n", " for sequences, targets in test_loader:\n", " sequences = sequences.to(DEVICE)\n", " organism_idx = torch.zeros(sequences.shape[0], dtype=torch.long, device=DEVICE)\n", " enc_out = model(sequences, organism_idx, encoder_only=True)[\"encoder_output\"]\n", " preds = head(enc_out)\n", " all_preds_test.append(preds.float().cpu().numpy())\n", " all_tgts_test.append(targets.numpy())\n", "\n", "preds_np = np.concatenate(all_preds_test)\n", "tgts_np = np.concatenate(all_tgts_test)\n", "\n", "pearson_val, _ = pearsonr(preds_np, tgts_np)\n", "spearman_val, _ = spearmanr(preds_np, tgts_np)\n", "\n", "print(f\"Test Pearson r : {pearson_val:.4f}\")\n", "print(f\"Test Spearman r : {spearman_val:.4f}\")\n", "\n", "# Scatter plot\n", "fig, ax = plt.subplots(figsize=(5, 5))\n", "ax.scatter(tgts_np, preds_np, alpha=0.2, s=3, color=\"steelblue\", rasterized=True)\n", "lims = [min(tgts_np.min(), preds_np.min()) - 0.1,\n", " max(tgts_np.max(), preds_np.max()) + 0.1]\n", "ax.plot(lims, lims, \"k--\", linewidth=0.8, alpha=0.5)\n", "ax.set_xlim(lims); ax.set_ylim(lims)\n", "ax.set_xlabel(\"Ground-truth activity (log scale)\")\n", "ax.set_ylabel(\"Predicted activity\")\n", "ax.set_title(\n", " f\"{CELL_TYPE} LentiMPRA — Test set\\n\"\n", " f\"Pearson r = {pearson_val:.4f} | Spearman r = {spearman_val:.4f}\"\n", ")\n", "ax.grid(True, alpha=0.3)\n", "plt.tight_layout()\n", "plt.savefig(CHECKPOINT_DIR / \"test_scatter.png\", dpi=150)\n", "plt.show()\n", "\n", "print(f\"Scatter saved to {CHECKPOINT_DIR / 'test_scatter.png'}\")" ] }, { "cell_type": "markdown", "id": "cell-26", "metadata": {}, "source": [ "## Summary\n", "\n", "Finetuning the encoder achieves\n", "**test Pearson r = 0.82+** on HepG2 LentiMPRA.\n", "\n", "### What we did:\n", "| Step | Description |\n", "|------|-------------|\n", "| `AlphaGenome()` + `load_trunk()` | Load pretrained backbone, exclude original heads |\n", "| Freeze backbone | Zero trainable backbone parameters |\n", "| `model(..., encoder_only=True)` | Run only the CNN encoder — skip transformer, decoder, embedders |\n", "| `MPRAHead` | LayerNorm → flatten → Linear → ReLU → Dropout → Linear(→1) |\n", "| MSE loss | Regression on log-scale MPRA activity scores |\n", "| Pearson r | Evaluation metric per epoch |" ] } ], "metadata": { "kernelspec": { "display_name": "ag-new", "language": "python", "name": "ag-new" }, "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.12.0" } }, "nbformat": 4, "nbformat_minor": 5 }