Skip to content

Instantly share code, notes, and snippets.

@wojtyniak

wojtyniak/notebook-9ade5839-4181-4061-90e1-982f6e7c61a4-paper-20260126-175826.ipynb

Created January 26, 2026 17:58
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save wojtyniak/5ceb4e142c8f5e87cfc2794f41251b97 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save wojtyniak/5ceb4e142c8f5e87cfc2794f41251b97 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
notebook-9ade5839-4181-4061-90e1-982f6e7c61a4-paper-20260126-175826.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# BioVERSE: Representation Alignment of Biomedical Modalities to LLMs\n",
"\n",
"## Educational Overview Notebook\n",
"\n",
"**Paper**: BioVERSE: Representation Alignment of Biomedical Modalities to LLMs for Multi-Modal Reasoning \n",
"**Authors**: Ching-Huei Tsou, Michal Ozery-Flato, Ella Barkan, Diwakar Mahajan, Ben Shapira\n",
"\n",
"---\n",
"\n",
"## Overview\n",
"\n",
"This notebook provides an **educational demonstration** of the BioVERSE framework, which aligns biomedical foundation model (BioFM) embeddings with large language models (LLMs) for multi-modal reasoning.\n",
"\n",
"**Key Concepts:**\n",
"- **Problem**: BioFMs (for proteins, molecules, scRNA-seq) and LLMs exist in different embedding spaces\n",
"- **Solution**: Train lightweight projection layers to align bio embeddings with LLM token space\n",
"- **Two-Stage Training**:\n",
" - Stage 1: Alignment (AR or CT modes)\n",
" - Stage 2: Instruction tuning with LoRA\n",
"\n",
"**Resource Constraints:**\n",
"- This notebook uses **toy datasets** and **simplified models** to run within:\n",
" - 4GB RAM maximum\n",
" - 5-10 minute execution time\n",
" - CPU-only environment (no GPU)\n",
"\n",
"**Note**: This is an educational overview. Full-scale experiments would require GPU resources and larger datasets."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Setup and Dependencies\n",
"\n",
"First, we install all required dependencies in a single command for compatibility checking."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# Install all dependencies at once\n",
"!uv pip install torch numpy scikit-learn matplotlib seaborn --quiet"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"✓ All libraries imported successfully\n",
"✓ PyTorch version: 2.10.0+cu128\n",
"✓ NumPy version: 2.4.1\n"
]
}
],
"source": [
"# Import required libraries\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"from sklearn.metrics.pairwise import cosine_similarity\n",
"import torch\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"from torch.utils.data import Dataset, DataLoader\n",
"import warnings\n",
"warnings.filterwarnings('ignore')\n",
"\n",
"# Set random seeds for reproducibility\n",
"np.random.seed(42)\n",
"torch.manual_seed(42)\n",
"\n",
"print(\"✓ All libraries imported successfully\")\n",
"print(f\"✓ PyTorch version: {torch.__version__}\")\n",
"print(f\"✓ NumPy version: {np.__version__}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Data Preparation: Synthetic Bio-Text Pairs\n",
"\n",
"We generate small synthetic datasets representing:\n",
"- **Biological entities** (proteins, molecules, cells) as embeddings\n",
"- **Text descriptions** as embeddings\n",
"\n",
"In practice, these would come from:\n",
"- BioFMs: scGPT (scRNA-seq), ESM-2 (proteins), ChemBERTa (molecules)\n",
"- LLM text encodings: Granite-8B or similar models"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Generating synthetic bio-text paired dataset...\n",
"✓ Generated 400 training pairs\n",
"✓ Generated 100 test pairs\n",
"✓ Bio embedding dimension (d_b): 512\n",
"✓ Text embedding dimension (d_t): 4096\n",
"\n",
"Example descriptions: ['Platelets', 'NK cells', 'B cells']\n"
]
}
],
"source": [
"class SyntheticBioTextDataset:\n",
" \"\"\"\n",
" Generate synthetic paired biological and text embeddings.\n",
" Simulates output from BioFM encoders and LLM text embeddings.\n",
" \"\"\"\n",
" def __init__(self, n_samples=500, bio_dim=512, text_dim=4096, n_classes=9):\n",
" \"\"\"\n",
" Args:\n",
" n_samples: Number of bio-text pairs\n",
" bio_dim: BioFM embedding dimension (d_b)\n",
" text_dim: LLM embedding dimension (d_t)\n",
" n_classes: Number of biological classes (e.g., cell types)\n",
" \"\"\"\n",
" self.n_samples = n_samples\n",
" self.bio_dim = bio_dim\n",
" self.text_dim = text_dim\n",
" self.n_classes = n_classes\n",
" \n",
" # Generate synthetic data\n",
" self._generate_data()\n",
" \n",
" def _generate_data(self):\n",
" \"\"\"Generate synthetic bio-text pairs with some correlation.\"\"\"\n",
" # Class labels (e.g., cell types, protein families)\n",
" self.labels = np.random.randint(0, self.n_classes, self.n_samples)\n",
" \n",
" # Create class-specific centroids\n",
" bio_centroids = np.random.randn(self.n_classes, self.bio_dim)\n",
" text_centroids = np.random.randn(self.n_classes, self.text_dim)\n",
" \n",
" # Generate biological embeddings (from \"BioFM\")\n",
" self.bio_embeddings = np.zeros((self.n_samples, self.bio_dim))\n",
" for i in range(self.n_samples):\n",
" label = self.labels[i]\n",
" # Add noise to centroid\n",
" self.bio_embeddings[i] = bio_centroids[label] + np.random.randn(self.bio_dim) * 0.3\n",
" \n",
" # Generate text embeddings (from \"LLM\")\n",
" self.text_embeddings = np.zeros((self.n_samples, self.text_dim))\n",
" for i in range(self.n_samples):\n",
" label = self.labels[i]\n",
" # Add noise to centroid\n",
" self.text_embeddings[i] = text_centroids[label] + np.random.randn(self.text_dim) * 0.3\n",
" \n",
" # Normalize embeddings (common practice)\n",
" self.bio_embeddings = self.bio_embeddings / (np.linalg.norm(self.bio_embeddings, axis=1, keepdims=True) + 1e-8)\n",
" self.text_embeddings = self.text_embeddings / (np.linalg.norm(self.text_embeddings, axis=1, keepdims=True) + 1e-8)\n",
" \n",
" # Generate text descriptions (simplified)\n",
" class_names = ['CD14+ Monocytes', 'CD4+ T cells', 'CD8+ T cells', 'B cells', \n",
" 'NK cells', 'Dendritic cells', 'Megakaryocytes', 'Platelets', 'Erythrocytes']\n",
" self.text_descriptions = [class_names[label] for label in self.labels]\n",
" \n",
" def get_train_test_split(self, test_size=0.2):\n",
" \"\"\"Split data into train and test sets.\"\"\"\n",
" n_test = int(self.n_samples * test_size)\n",
" indices = np.random.permutation(self.n_samples)\n",
" \n",
" train_idx = indices[n_test:]\n",
" test_idx = indices[:n_test]\n",
" \n",
" return (\n",
" self.bio_embeddings[train_idx], self.text_embeddings[train_idx], \n",
" self.labels[train_idx], [self.text_descriptions[i] for i in train_idx],\n",
" self.bio_embeddings[test_idx], self.text_embeddings[test_idx],\n",
" self.labels[test_idx], [self.text_descriptions[i] for i in test_idx]\n",
" )\n",
"\n",
"# Generate synthetic dataset\n",
"print(\"Generating synthetic bio-text paired dataset...\")\n",
"dataset = SyntheticBioTextDataset(n_samples=500, bio_dim=512, text_dim=4096, n_classes=9)\n",
"\n",
"# Get train/test split\n",
"bio_train, text_train, labels_train, desc_train, bio_test, text_test, labels_test, desc_test = dataset.get_train_test_split()\n",
"\n",
"print(f\"✓ Generated {len(bio_train)} training pairs\")\n",
"print(f\"✓ Generated {len(bio_test)} test pairs\")\n",
"print(f\"✓ Bio embedding dimension (d_b): {bio_train.shape[1]}\")\n",
"print(f\"✓ Text embedding dimension (d_t): {text_train.shape[1]}\")\n",
"print(f\"\\nExample descriptions: {desc_train[:3]}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. Projection Layer Architecture\n",
"\n",
"The projection layer $P_\\theta$ maps BioFM embeddings from dimension $d_b$ to LLM dimension $d_t$.\n",
"\n",
"**Architecture** (from paper Section 3.3):\n",
"- 3-layer MLP with ReLU activations\n",
"- Layer normalization for stability\n",
"- Dropout for regularization\n",
"\n",
"**Mathematical formulation**:\n",
"$$\\tilde{z}_b = P_\\theta(z_b)$$\n",
"\n",
"where $z_b \\in \\mathbb{R}^{d_b}$ and $\\tilde{z}_b \\in \\mathbb{R}^{d_t}$"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"✓ Projection layer initialized\n",
"✓ Parameters: 13,656,064\n",
"✓ Trainable parameters: 13,656,064\n"
]
}
],
"source": [
"class ProjectionLayer(nn.Module):\n",
" \"\"\"\n",
" Lightweight MLP projection layer that maps BioFM embeddings to LLM space.\n",
" Based on BioVERSE paper Section 3.3.\n",
" \"\"\"\n",
" def __init__(self, bio_dim, llm_dim, hidden_dim=2048, dropout=0.1):\n",
" \"\"\"\n",
" Args:\n",
" bio_dim: BioFM embedding dimension (d_b)\n",
" llm_dim: LLM embedding dimension (d_t)\n",
" hidden_dim: Hidden layer dimension\n",
" dropout: Dropout rate for regularization\n",
" \"\"\"\n",
" super(ProjectionLayer, self).__init__()\n",
" \n",
" # 3-layer MLP as described in the paper\n",
" self.mlp = nn.Sequential(\n",
" nn.Linear(bio_dim, hidden_dim),\n",
" nn.LayerNorm(hidden_dim),\n",
" nn.ReLU(),\n",
" nn.Dropout(dropout),\n",
" \n",
" nn.Linear(hidden_dim, hidden_dim),\n",
" nn.LayerNorm(hidden_dim),\n",
" nn.ReLU(),\n",
" nn.Dropout(dropout),\n",
" \n",
" nn.Linear(hidden_dim, llm_dim),\n",
" nn.LayerNorm(llm_dim)\n",
" )\n",
" \n",
" # Initialize weights\n",
" self._init_weights()\n",
" \n",
" def _init_weights(self):\n",
" \"\"\"Initialize weights with Xavier initialization.\"\"\"\n",
" for module in self.modules():\n",
" if isinstance(module, nn.Linear):\n",
" nn.init.xavier_uniform_(module.weight)\n",
" if module.bias is not None:\n",
" nn.init.zeros_(module.bias)\n",
" \n",
" def forward(self, bio_embeddings):\n",
" \"\"\"\n",
" Project biological embeddings to LLM space.\n",
" \n",
" Args:\n",
" bio_embeddings: Tensor of shape (batch_size, bio_dim)\n",
" \n",
" Returns:\n",
" projected: Tensor of shape (batch_size, llm_dim)\n",
" \"\"\"\n",
" return self.mlp(bio_embeddings)\n",
"\n",
"# Create projection layer\n",
"projection = ProjectionLayer(bio_dim=512, llm_dim=4096, hidden_dim=2048)\n",
"print(f\"✓ Projection layer initialized\")\n",
"print(f\"✓ Parameters: {sum(p.numel() for p in projection.parameters()):,}\")\n",
"print(f\"✓ Trainable parameters: {sum(p.numel() for p in projection.parameters() if p.requires_grad):,}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. Stage 1 Alignment - Autoregressive (AR) Mode\n",
"\n",
"**Autoregressive alignment** (Section 3.4) trains the projection layer using cross-entropy loss.\n",
"\n",
"**Loss function**:\n",
"$$\\mathcal{L}_{AR} = -\\sum_{i=1}^{|t_b|} \\log p_{LLM}(t_i | \\tilde{z}_b, q, t_{<i})$$\n",
"\n",
"**Key idea**: Teach the LLM to attend to bio tokens during generation.\n",
"\n",
"**Simplified implementation**: We simulate this with next-token prediction on text embeddings."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Training Stage 1 (AR Alignment)...\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [2/10], Loss: 1.3867\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [4/10], Loss: 1.3296\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [6/10], Loss: 1.3184\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [8/10], Loss: 1.2631\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [10/10], Loss: 1.2653\n",
"✓ AR Alignment training completed\n"
]
}
],
"source": [
"class AutoregressiveAlignmentLoss(nn.Module):\n",
" \"\"\"\n",
" Simplified autoregressive alignment loss.\n",
" In practice, this would use the LLM's forward pass.\n",
" \"\"\"\n",
" def __init__(self, temperature=0.07):\n",
" super(AutoregressiveAlignmentLoss, self).__init__()\n",
" self.temperature = temperature\n",
" \n",
" def forward(self, projected_bio, text_embeddings):\n",
" \"\"\"\n",
" Compute alignment loss between projected bio and text embeddings.\n",
" \n",
" Args:\n",
" projected_bio: Projected biological embeddings (batch_size, llm_dim)\n",
" text_embeddings: Target text embeddings (batch_size, llm_dim)\n",
" \n",
" Returns:\n",
" loss: Scalar alignment loss\n",
" \"\"\"\n",
" # Normalize embeddings\n",
" projected_bio = F.normalize(projected_bio, p=2, dim=1)\n",
" text_embeddings = F.normalize(text_embeddings, p=2, dim=1)\n",
" \n",
" # Compute cosine similarity\n",
" logits = torch.matmul(projected_bio, text_embeddings.t()) / self.temperature\n",
" \n",
" # Create labels (diagonal entries are positive pairs)\n",
" labels = torch.arange(logits.size(0), device=logits.device)\n",
" \n",
" # Cross-entropy loss\n",
" loss = F.cross_entropy(logits, labels)\n",
" \n",
" return loss\n",
"\n",
"def train_ar_alignment(projection, bio_train, text_train, epochs=10, batch_size=32, lr=1e-3):\n",
" \"\"\"\n",
" Train projection layer with autoregressive alignment.\n",
" \n",
" Args:\n",
" projection: ProjectionLayer model\n",
" bio_train: Training biological embeddings\n",
" text_train: Training text embeddings\n",
" epochs: Number of training epochs\n",
" batch_size: Batch size for training\n",
" lr: Learning rate\n",
" \n",
" Returns:\n",
" losses: List of training losses\n",
" \"\"\"\n",
" # Convert to tensors\n",
" bio_tensor = torch.FloatTensor(bio_train)\n",
" text_tensor = torch.FloatTensor(text_train)\n",
" \n",
" # Create data loader\n",
" dataset_train = torch.utils.data.TensorDataset(bio_tensor, text_tensor)\n",
" loader = DataLoader(dataset_train, batch_size=batch_size, shuffle=True)\n",
" \n",
" # Setup training\n",
" criterion = AutoregressiveAlignmentLoss()\n",
" optimizer = torch.optim.AdamW(projection.parameters(), lr=lr, weight_decay=0.01)\n",
" \n",
" losses = []\n",
" projection.train()\n",
" \n",
" print(\"Training Stage 1 (AR Alignment)...\")\n",
" for epoch in range(epochs):\n",
" epoch_loss = 0.0\n",
" for bio_batch, text_batch in loader:\n",
" optimizer.zero_grad()\n",
" \n",
" # Project bio embeddings\n",
" projected = projection(bio_batch)\n",
" \n",
" # Compute loss\n",
" loss = criterion(projected, text_batch)\n",
" \n",
" # Backpropagation\n",
" loss.backward()\n",
" optimizer.step()\n",
" \n",
" epoch_loss += loss.item()\n",
" \n",
" avg_loss = epoch_loss / len(loader)\n",
" losses.append(avg_loss)\n",
" \n",
" if (epoch + 1) % 2 == 0:\n",
" print(f\"Epoch [{epoch+1}/{epochs}], Loss: {avg_loss:.4f}\")\n",
" \n",
" print(\"✓ AR Alignment training completed\")\n",
" return losses\n",
"\n",
"# Train with AR alignment\n",
"ar_losses = train_ar_alignment(projection, bio_train, text_train, epochs=10, batch_size=32)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5. Stage 1 Alignment - Contrastive (CT) Mode\n",
"\n",
"**Contrastive alignment** (Section 3.4) uses bidirectional InfoNCE loss (CLIP-style).\n",
"\n",
"**Loss function**:\n",
"$$\\mathcal{L}_{CT} = -\\frac{1}{2N}\\sum_{i=1}^{N} \\left[ \\log \\frac{\\exp(\\text{sim}(\\tilde{z}_b^{(i)}, \\phi(t_b^{(i)}))/\\tau)}{\\sum_{j=1}^{N} \\exp(\\text{sim}(\\tilde{z}_b^{(i)}, \\phi(t_b^{(j)}))/\\tau)} + \\log \\frac{\\exp(\\text{sim}(\\phi(t_b^{(i)}), \\tilde{z}_b^{(i)})/\\tau)}{\\sum_{j=1}^{N} \\exp(\\text{sim}(\\phi(t_b^{(i)}), \\tilde{z}_b^{(j)})/\\tau)} \\right]$$\n",
"\n",
"**Advantages**:\n",
"- Bypasses LLM forward pass (more efficient)\n",
"- Enforces representation-level similarity\n",
"- More isotropic embedding spaces"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Training Stage 1 (CT Alignment)...\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [2/10], Loss: 1.3310\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [4/10], Loss: 1.3630\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [6/10], Loss: 1.2945\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [8/10], Loss: 1.3369\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch [10/10], Loss: 1.3046\n",
"✓ CT Alignment training completed\n"
]
}
],
"source": [
"class ContrastiveAlignmentLoss(nn.Module):\n",
" \"\"\"\n",
" Bidirectional InfoNCE contrastive loss (CLIP-style).\n",
" Based on BioVERSE paper Section 3.4.\n",
" \"\"\"\n",
" def __init__(self, temperature=0.07):\n",
" super(ContrastiveAlignmentLoss, self).__init__()\n",
" self.temperature = nn.Parameter(torch.tensor(temperature))\n",
" \n",
" def forward(self, bio_embeddings, text_embeddings):\n",
" \"\"\"\n",
" Compute bidirectional contrastive loss.\n",
" \n",
" Args:\n",
" bio_embeddings: Projected biological embeddings (N, llm_dim)\n",
" text_embeddings: Text embeddings (N, llm_dim)\n",
" \n",
" Returns:\n",
" loss: Bidirectional contrastive loss\n",
" \"\"\"\n",
" # Normalize embeddings\n",
" bio_embeddings = F.normalize(bio_embeddings, p=2, dim=1)\n",
" text_embeddings = F.normalize(text_embeddings, p=2, dim=1)\n",
" \n",
" # Compute similarity matrix\n",
" logits_bio_to_text = torch.matmul(bio_embeddings, text_embeddings.t()) / self.temperature\n",
" logits_text_to_bio = logits_bio_to_text.t()\n",
" \n",
" # Labels: diagonal entries are positive pairs\n",
" labels = torch.arange(logits_bio_to_text.size(0), device=logits_bio_to_text.device)\n",
" \n",
" # Bidirectional cross-entropy loss\n",
" loss_bio_to_text = F.cross_entropy(logits_bio_to_text, labels)\n",
" loss_text_to_bio = F.cross_entropy(logits_text_to_bio, labels)\n",
" \n",
" # Average both directions\n",
" loss = (loss_bio_to_text + loss_text_to_bio) / 2\n",
" \n",
" return loss\n",
"\n",
"def train_ct_alignment(projection, bio_train, text_train, epochs=10, batch_size=32, lr=1e-3):\n",
" \"\"\"\n",
" Train projection layer with contrastive alignment.\n",
" \n",
" Args:\n",
" projection: ProjectionLayer model\n",
" bio_train: Training biological embeddings\n",
" text_train: Training text embeddings\n",
" epochs: Number of training epochs\n",
" batch_size: Batch size for training\n",
" lr: Learning rate\n",
" \n",
" Returns:\n",
" losses: List of training losses\n",
" \"\"\"\n",
" # Convert to tensors\n",
" bio_tensor = torch.FloatTensor(bio_train)\n",
" text_tensor = torch.FloatTensor(text_train)\n",
" \n",
" # Create data loader\n",
" dataset_train = torch.utils.data.TensorDataset(bio_tensor, text_tensor)\n",
" loader = DataLoader(dataset_train, batch_size=batch_size, shuffle=True)\n",
" \n",
" # Setup training\n",
" criterion = ContrastiveAlignmentLoss()\n",
" optimizer = torch.optim.AdamW(projection.parameters(), lr=lr, weight_decay=0.01)\n",
" \n",
" losses = []\n",
" projection.train()\n",
" \n",
" print(\"\\nTraining Stage 1 (CT Alignment)...\")\n",
" for epoch in range(epochs):\n",
" epoch_loss = 0.0\n",
" for bio_batch, text_batch in loader:\n",
" optimizer.zero_grad()\n",
" \n",
" # Project bio embeddings\n",
" projected = projection(bio_batch)\n",
" \n",
" # Compute bidirectional contrastive loss\n",
" loss = criterion(projected, text_batch)\n",
" \n",
" # Backpropagation\n",
" loss.backward()\n",
" optimizer.step()\n",
" \n",
" epoch_loss += loss.item()\n",
" \n",
" avg_loss = epoch_loss / len(loader)\n",
" losses.append(avg_loss)\n",
" \n",
" if (epoch + 1) % 2 == 0:\n",
" print(f\"Epoch [{epoch+1}/{epochs}], Loss: {avg_loss:.4f}\")\n",
" \n",
" print(\"✓ CT Alignment training completed\")\n",
" return losses\n",
"\n",
"# Create a new projection layer for CT training\n",
"projection_ct = ProjectionLayer(bio_dim=512, llm_dim=4096, hidden_dim=2048)\n",
"ct_losses = train_ct_alignment(projection_ct, bio_train, text_train, epochs=10, batch_size=32)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 6. Visualize Training Progress"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x500 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data",
"transient": {}
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"✓ Training curves plotted\n"
]
}
],
"source": [
"# Plot training losses\n",
"plt.figure(figsize=(10, 5))\n",
"plt.plot(ar_losses, label='AR Alignment', marker='o')\n",
"plt.plot(ct_losses, label='CT Alignment', marker='s')\n",
"plt.xlabel('Epoch')\n",
"plt.ylabel('Loss')\n",
"plt.title('Stage 1 Alignment Training Loss')\n",
"plt.legend()\n",
"plt.grid(True, alpha=0.3)\n",
"plt.tight_layout()\n",
"plt.show()\n",
"\n",
"print(\"✓ Training curves plotted\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7. Embedding Alignment Visualization (t-SNE)\n",
"\n",
"**Workflow 4** from the paper: Visualize embeddings before and after alignment.\n",
"\n",
"**Key result** (Figure 2 in paper): After alignment, bio embeddings move closer to their corresponding text embeddings in the LLM space.\n",
"\n",
"**Note**: The paper uses UMAP, but we use t-SNE here for Python 3.13 compatibility."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Applying t-SNE to 200 embeddings...\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x800 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data",
"transient": {}
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"✓ t-SNE visualization completed\n"
]
}
],
"source": [
"from sklearn.manifold import TSNE\n",
"\n",
"def visualize_alignment(bio_embeddings, text_embeddings, labels, projection_model, title=\"Embedding Alignment\"):\n",
" \"\"\"\n",
" Visualize bio and text embeddings using t-SNE.\n",
" \n",
" Args:\n",
" bio_embeddings: Biological embeddings (before projection)\n",
" text_embeddings: Text embeddings\n",
" labels: Class labels for coloring\n",
" projection_model: Trained projection layer\n",
" title: Plot title\n",
" \"\"\"\n",
" # Project bio embeddings\n",
" with torch.no_grad():\n",
" bio_tensor = torch.FloatTensor(bio_embeddings)\n",
" projected_bio = projection_model(bio_tensor).numpy()\n",
" \n",
" # Combine all embeddings for t-SNE\n",
" all_embeddings = np.vstack([projected_bio, text_embeddings])\n",
" \n",
" # Create modality labels\n",
" modality_labels = ['Bio'] * len(bio_embeddings) + ['Text'] * len(text_embeddings)\n",
" class_labels = np.concatenate([labels, labels])\n",
" \n",
" # Apply t-SNE (faster than UMAP, works with Python 3.13)\n",
" print(f\"Applying t-SNE to {all_embeddings.shape[0]} embeddings...\")\n",
" tsne_model = TSNE(n_components=2, perplexity=30, random_state=42, max_iter=300)\n",
" embeddings_2d = tsne_model.fit_transform(all_embeddings)\n",
" \n",
" # Split back into bio and text\n",
" bio_2d = embeddings_2d[:len(bio_embeddings)]\n",
" text_2d = embeddings_2d[len(bio_embeddings):]\n",
" \n",
" # Plot\n",
" plt.figure(figsize=(10, 8))\n",
" \n",
" # Plot bio embeddings (green)\n",
" scatter1 = plt.scatter(bio_2d[:, 0], bio_2d[:, 1], \n",
" c=labels, cmap='tab10', \n",
" marker='o', s=50, alpha=0.6, \n",
" edgecolors='darkgreen', linewidths=1,\n",
" label='Bio embeddings')\n",
" \n",
" # Plot text embeddings (blue)\n",
" scatter2 = plt.scatter(text_2d[:, 0], text_2d[:, 1], \n",
" c=labels, cmap='tab10',\n",
" marker='^', s=50, alpha=0.6,\n",
" edgecolors='darkblue', linewidths=1,\n",
" label='Text embeddings')\n",
" \n",
" plt.xlabel('t-SNE 1', fontsize=12)\n",
" plt.ylabel('t-SNE 2', fontsize=12)\n",
" plt.title(title, fontsize=14, fontweight='bold')\n",
" plt.legend(loc='best', fontsize=10)\n",
" plt.grid(True, alpha=0.3)\n",
" plt.tight_layout()\n",
" plt.show()\n",
" \n",
" print(f\"✓ t-SNE visualization completed\")\n",
"\n",
"# Visualize alignment with AR-trained projection\n",
"visualize_alignment(bio_test, text_test, labels_test, projection, \n",
" title=\"Embedding Alignment After AR Training (t-SNE)\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 8. Evaluate Alignment Quality\n",
"\n",
"Measure how well biological and text embeddings are aligned after projection."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Evaluating AR alignment quality...\n",
"\n",
"AR Alignment Metrics:\n",
" Same-pair similarity: 0.6838\n",
" Same-class similarity: 0.6877\n",
" Diff-class similarity: -0.0884\n",
" Alignment gap: 0.7722\n",
"\n",
"Evaluating CT alignment quality...\n",
"\n",
"CT Alignment Metrics:\n",
" Same-pair similarity: 0.6837\n",
" Same-class similarity: 0.6832\n",
" Diff-class similarity: -0.0546\n",
" Alignment gap: 0.7383\n"
]
}
],
"source": [
"def evaluate_alignment(bio_embeddings, text_embeddings, labels, projection_model):\n",
" \"\"\"\n",
" Evaluate alignment quality using similarity metrics.\n",
" \n",
" Args:\n",
" bio_embeddings: Biological embeddings\n",
" text_embeddings: Text embeddings\n",
" labels: Class labels\n",
" projection_model: Trained projection layer\n",
" \n",
" Returns:\n",
" metrics: Dictionary of evaluation metrics\n",
" \"\"\"\n",
" projection_model.eval()\n",
" with torch.no_grad():\n",
" # Project bio embeddings\n",
" bio_tensor = torch.FloatTensor(bio_embeddings)\n",
" projected_bio = projection_model(bio_tensor).numpy()\n",
" \n",
" # Normalize embeddings\n",
" projected_bio = projected_bio / (np.linalg.norm(projected_bio, axis=1, keepdims=True) + 1e-8)\n",
" text_norm = text_embeddings / (np.linalg.norm(text_embeddings, axis=1, keepdims=True) + 1e-8)\n",
" \n",
" # Compute cosine similarities\n",
" similarities = cosine_similarity(projected_bio, text_norm)\n",
" \n",
" # Diagonal similarities (same-pair similarities)\n",
" same_pair_sim = np.diag(similarities)\n",
" \n",
" # Average similarity for same class vs different class\n",
" same_class_sims = []\n",
" diff_class_sims = []\n",
" \n",
" for i in range(len(labels)):\n",
" for j in range(len(labels)):\n",
" if i != j:\n",
" if labels[i] == labels[j]:\n",
" same_class_sims.append(similarities[i, j])\n",
" else:\n",
" diff_class_sims.append(similarities[i, j])\n",
" \n",
" metrics = {\n",
" 'avg_same_pair_similarity': np.mean(same_pair_sim),\n",
" 'avg_same_class_similarity': np.mean(same_class_sims) if same_class_sims else 0,\n",
" 'avg_diff_class_similarity': np.mean(diff_class_sims),\n",
" 'alignment_gap': np.mean(same_pair_sim) - np.mean(diff_class_sims)\n",
" }\n",
" \n",
" return metrics\n",
"\n",
"# Evaluate AR alignment\n",
"print(\"Evaluating AR alignment quality...\")\n",
"ar_metrics = evaluate_alignment(bio_test, text_test, labels_test, projection)\n",
"print(f\"\\nAR Alignment Metrics:\")\n",
"print(f\" Same-pair similarity: {ar_metrics['avg_same_pair_similarity']:.4f}\")\n",
"print(f\" Same-class similarity: {ar_metrics['avg_same_class_similarity']:.4f}\")\n",
"print(f\" Diff-class similarity: {ar_metrics['avg_diff_class_similarity']:.4f}\")\n",
"print(f\" Alignment gap: {ar_metrics['alignment_gap']:.4f}\")\n",
"\n",
"# Evaluate CT alignment\n",
"print(\"\\nEvaluating CT alignment quality...\")\n",
"ct_metrics = evaluate_alignment(bio_test, text_test, labels_test, projection_ct)\n",
"print(f\"\\nCT Alignment Metrics:\")\n",
"print(f\" Same-pair similarity: {ct_metrics['avg_same_pair_similarity']:.4f}\")\n",
"print(f\" Same-class similarity: {ct_metrics['avg_same_class_similarity']:.4f}\")\n",
"print(f\" Diff-class similarity: {ct_metrics['avg_diff_class_similarity']:.4f}\")\n",
"print(f\" Alignment gap: {ct_metrics['alignment_gap']:.4f}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 9. Bio Token Injection for Inference\n",
"\n",
"**Key mechanism**: Inject projected bio embeddings at `[BIO]` placeholder positions in the prompt.\n",
"\n",
"**Inference workflow** (Section 3.3):\n",
"1. Encode biological input with BioFM: $z_b = f_b(x_b)$\n",
"2. Project to LLM space: $\\tilde{z}_b = P_\\theta(z_b)$\n",
"3. Replace `[BIO]` marker with $\\tilde{z}_b$ as soft tokens\n",
"4. Generate text with LLM"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"============================================================\n",
"Example: Bio Token Injection for Inference\n",
"============================================================\n",
"\n",
"True label: NK cells\n",
"Query: What cell type matches this [BIO] gene-expression profile?\n",
"\n",
"Bio embedding shape: (512,)\n",
"Projected bio embedding shape: torch.Size([1, 4096])\n",
"\n",
"In practice, [BIO] in the query would be replaced with the projected embedding.\n",
"The LLM would then attend to this soft token during generation.\n",
"\n",
"✓ Bio token ready for LLM injection\n"
]
}
],
"source": [
"def simulate_bio_token_injection(bio_embedding, projection_model, query=\"What cell type is this?\"):\n",
" \"\"\"\n",
" Simulate bio token injection for inference.\n",
" \n",
" Args:\n",
" bio_embedding: Biological embedding from BioFM\n",
" projection_model: Trained projection layer\n",
" query: User query with [BIO] placeholder\n",
" \n",
" Returns:\n",
" projected_bio: Projected embedding ready for LLM injection\n",
" \"\"\"\n",
" projection_model.eval()\n",
" with torch.no_grad():\n",
" # Project bio embedding to LLM space\n",
" bio_tensor = torch.FloatTensor(bio_embedding).unsqueeze(0)\n",
" projected_bio = projection_model(bio_tensor)\n",
" \n",
" print(f\"Query: {query}\")\n",
" print(f\"\\nBio embedding shape: {bio_embedding.shape}\")\n",
" print(f\"Projected bio embedding shape: {projected_bio.shape}\")\n",
" print(f\"\\nIn practice, [BIO] in the query would be replaced with the projected embedding.\")\n",
" print(f\"The LLM would then attend to this soft token during generation.\")\n",
" \n",
" return projected_bio.numpy()\n",
"\n",
"# Example: inject bio token for a test sample\n",
"print(\"=\" * 60)\n",
"print(\"Example: Bio Token Injection for Inference\")\n",
"print(\"=\" * 60)\n",
"\n",
"sample_idx = 0\n",
"sample_bio = bio_test[sample_idx]\n",
"sample_label = labels_test[sample_idx]\n",
"sample_desc = desc_test[sample_idx]\n",
"\n",
"print(f\"\\nTrue label: {sample_desc}\")\n",
"projected = simulate_bio_token_injection(sample_bio, projection, \n",
" query=\"What cell type matches this [BIO] gene-expression profile?\")\n",
"\n",
"print(f\"\\n✓ Bio token ready for LLM injection\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 10. Zero-Shot Cell Type Annotation (Simplified)\n",
"\n",
"**Task**: Predict cell type from scRNA-seq embeddings using aligned projections.\n",
"\n",
"**Approach** (simplified for demonstration):\n",
"1. Project bio embeddings to LLM space\n",
"2. Find nearest text embedding\n",
"3. Return corresponding cell type\n",
"\n",
"**Note**: The full BioVERSE approach uses generative LLM output. Here we use retrieval for simplicity."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"============================================================\n",
"Zero-Shot Cell Type Annotation (Simplified)\n",
"============================================================\n",
"\n",
"Accuracy: 100.00%\n",
"\n",
"Example predictions:\n",
" True: NK cells | Predicted: NK cells \n",
" True: CD14+ Monocytes | Predicted: CD14+ Monocytes \n",
" True: NK cells | Predicted: NK cells \n",
" True: CD8+ T cells | Predicted: CD8+ T cells \n",
" True: CD8+ T cells | Predicted: CD8+ T cells \n",
"\n",
"✓ Zero-shot annotation completed\n",
"\n",
"Note: Full BioVERSE uses generative LLM output with reasoning.\n",
"This is a simplified retrieval-based demonstration.\n"
]
}
],
"source": [
"def zero_shot_cell_annotation(bio_test, text_train, desc_train, labels_test, projection_model):\n",
" \"\"\"\n",
" Simplified zero-shot cell type annotation using nearest neighbor matching.\n",
" \n",
" Args:\n",
" bio_test: Test biological embeddings\n",
" text_train: Training text embeddings (reference)\n",
" desc_train: Training text descriptions (reference labels)\n",
" labels_test: True labels for evaluation\n",
" projection_model: Trained projection layer\n",
" \n",
" Returns:\n",
" accuracy: Prediction accuracy\n",
" \"\"\"\n",
" projection_model.eval()\n",
" with torch.no_grad():\n",
" # Project test bio embeddings\n",
" bio_tensor = torch.FloatTensor(bio_test)\n",
" projected_bio = projection_model(bio_tensor).numpy()\n",
" \n",
" # Normalize\n",
" projected_bio = projected_bio / (np.linalg.norm(projected_bio, axis=1, keepdims=True) + 1e-8)\n",
" text_norm = text_train / (np.linalg.norm(text_train, axis=1, keepdims=True) + 1e-8)\n",
" \n",
" # Compute similarities\n",
" similarities = cosine_similarity(projected_bio, text_norm)\n",
" \n",
" # Get nearest neighbor predictions\n",
" nearest_idx = np.argmax(similarities, axis=1)\n",
" predictions = [desc_train[idx] for idx in nearest_idx]\n",
" \n",
" # Compute accuracy\n",
" ground_truth = [desc_test[i] for i in range(len(labels_test))]\n",
" correct = sum([1 for pred, true in zip(predictions, ground_truth) if pred == true])\n",
" accuracy = correct / len(predictions)\n",
" \n",
" return accuracy, predictions\n",
"\n",
"# Evaluate zero-shot annotation\n",
"print(\"=\" * 60)\n",
"print(\"Zero-Shot Cell Type Annotation (Simplified)\")\n",
"print(\"=\" * 60)\n",
"\n",
"accuracy, predictions = zero_shot_cell_annotation(bio_test, text_train, desc_train, \n",
" labels_test, projection)\n",
"\n",
"print(f\"\\nAccuracy: {accuracy:.2%}\")\n",
"print(f\"\\nExample predictions:\")\n",
"for i in range(min(5, len(predictions))):\n",
" print(f\" True: {desc_test[i]:20s} | Predicted: {predictions[i]:20s}\")\n",
"\n",
"print(f\"\\n✓ Zero-shot annotation completed\")\n",
"print(f\"\\nNote: Full BioVERSE uses generative LLM output with reasoning.\")\n",
"print(f\"This is a simplified retrieval-based demonstration.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 11. Comparison: AR vs CT Alignment\n",
"\n",
"Compare the two alignment strategies on downstream task performance."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"============================================================\n",
"Comparing AR vs CT Alignment Strategies\n",
"============================================================\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1400x500 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data",
"transient": {}
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"✓ Comparison completed\n",
"\n",
"AR Alignment: 100.00% accuracy, 0.772 gap\n",
"CT Alignment: 100.00% accuracy, 0.738 gap\n"
]
}
],
"source": [
"# Evaluate both alignment strategies\n",
"print(\"=\" * 60)\n",
"print(\"Comparing AR vs CT Alignment Strategies\")\n",
"print(\"=\" * 60)\n",
"\n",
"# AR alignment\n",
"ar_accuracy, _ = zero_shot_cell_annotation(bio_test, text_train, desc_train, \n",
" labels_test, projection)\n",
"\n",
"# CT alignment\n",
"ct_accuracy, _ = zero_shot_cell_annotation(bio_test, text_train, desc_train, \n",
" labels_test, projection_ct)\n",
"\n",
"# Plot comparison\n",
"fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
"\n",
"# Accuracy comparison\n",
"methods = ['AR Alignment', 'CT Alignment']\n",
"accuracies = [ar_accuracy, ct_accuracy]\n",
"colors = ['#2ecc71', '#3498db']\n",
"\n",
"axes[0].bar(methods, accuracies, color=colors, alpha=0.7, edgecolor='black')\n",
"axes[0].set_ylabel('Accuracy', fontsize=12)\n",
"axes[0].set_title('Zero-Shot Cell Type Annotation', fontsize=13, fontweight='bold')\n",
"axes[0].set_ylim([0, 1])\n",
"axes[0].grid(True, alpha=0.3, axis='y')\n",
"\n",
"# Add value labels on bars\n",
"for i, (method, acc) in enumerate(zip(methods, accuracies)):\n",
" axes[0].text(i, acc + 0.02, f'{acc:.2%}', ha='center', fontsize=11, fontweight='bold')\n",
"\n",
"# Alignment gap comparison\n",
"alignment_gaps = [ar_metrics['alignment_gap'], ct_metrics['alignment_gap']]\n",
"axes[1].bar(methods, alignment_gaps, color=colors, alpha=0.7, edgecolor='black')\n",
"axes[1].set_ylabel('Alignment Gap', fontsize=12)\n",
"axes[1].set_title('Alignment Quality (Higher is Better)', fontsize=13, fontweight='bold')\n",
"axes[1].grid(True, alpha=0.3, axis='y')\n",
"\n",
"for i, (method, gap) in enumerate(zip(methods, alignment_gaps)):\n",
" axes[1].text(i, gap + 0.01, f'{gap:.3f}', ha='center', fontsize=11, fontweight='bold')\n",
"\n",
"plt.tight_layout()\n",
"plt.show()\n",
"\n",
"print(f\"\\n✓ Comparison completed\")\n",
"print(f\"\\nAR Alignment: {ar_accuracy:.2%} accuracy, {ar_metrics['alignment_gap']:.3f} gap\")\n",
"print(f\"CT Alignment: {ct_accuracy:.2%} accuracy, {ct_metrics['alignment_gap']:.3f} gap\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 12. Summary and Key Takeaways\n",
"\n",
"### What We Demonstrated:\n",
"\n",
"1. **Projection Layer Architecture**: Lightweight MLP that maps BioFM embeddings to LLM space\n",
"\n",
"2. **Two Alignment Strategies**:\n",
" - **AR (Autoregressive)**: Uses LLM forward pass for alignment\n",
" - **CT (Contrastive)**: CLIP-style bidirectional InfoNCE loss\n",
"\n",
"3. **Bio Token Injection**: Mechanism to insert biological embeddings as soft tokens in LLM prompts\n",
"\n",
"4. **Visualization**: UMAP shows how embeddings align after training\n",
"\n",
"5. **Downstream Task**: Zero-shot cell type annotation (simplified)\n",
"\n",
"### Key Results from Paper:\n",
"\n",
"- **BioVERSE outperforms larger LLM baselines** (compact 8B model beats 120B models)\n",
"- **Enables multi-modal reasoning** across proteins, molecules, and scRNA-seq\n",
"- **Two-stage training** (S1 + S2) is more effective than longer S1 only\n",
"- **Generative approach** provides interpretable outputs with reasoning\n",
"\n",
"### Scaling to Full Experiments:\n",
"\n",
"To replicate the paper's full results, you would need:\n",
"\n",
"1. **Large-scale datasets**:\n",
" - UniProtKB for proteins (~500K examples)\n",
" - LLASmol for molecules (~130K examples)\n",
" - CellxGene for scRNA-seq (~1.8K datasets)\n",
"\n",
"2. **Pre-trained models**:\n",
" - BioFMs: scGPT, ESM-2, ChemBERTa, MAMMAL\n",
" - LLM: Granite-3.3-8B-Instruct or larger\n",
"\n",
"3. **Computational resources**:\n",
" - GPU with 40GB+ VRAM (A100 recommended)\n",
" - Training time: Hours to days depending on dataset size\n",
" - Stage 1: 30K-500K iterations\n",
" - Stage 2: LoRA fine-tuning with instruction data\n",
"\n",
"4. **Evaluation benchmarks**:\n",
" - Mol-Instructions (5 tasks)\n",
" - scEval PBMC10K (9 cell types)\n",
" - BERTScore, ROUGE-L, LLM-as-judge metrics\n",
"\n",
"### Educational Purpose:\n",
"\n",
"This notebook demonstrates the **core concepts and workflows** of BioVERSE using:\n",
"- Synthetic data (500 samples)\n",
"- Simplified models\n",
"- CPU-only execution\n",
"- ~5-10 minute runtime\n",
"\n",
"The principles and code structure can be adapted for full-scale experiments on your own infrastructure.\n",
"\n",
"---\n",
"\n",
"**Paper Reference**: Tsou et al., \"BioVERSE: Representation Alignment of Biomedical Modalities to LLMs for Multi-Modal Reasoning\", 2025"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 13. Implementation Notes for Researchers\n",
"\n",
"### How to Adapt This Notebook for Your Research:\n",
"\n",
"1. **Replace synthetic data with real BioFM embeddings**:\n",
" ```python\n",
" # Example: Load scGPT embeddings\n",
" from scgpt import scGPT\n",
" model = scGPT.load_pretrained()\n",
" bio_embeddings = model.encode(scrnaseq_data)\n",
" ```\n",
"\n",
"2. **Use actual LLM for text embeddings**:\n",
" ```python\n",
" # Example: Load Granite-8B\n",
" from transformers import AutoModel, AutoTokenizer\n",
" model = AutoModel.from_pretrained(\"ibm-granite/granite-3.3-8b-instruct\")\n",
" text_embeddings = model.encode(text_descriptions)\n",
" ```\n",
"\n",
"3. **Scale up training**:\n",
" - Increase dataset size (30K-500K iterations)\n",
" - Use GPU acceleration\n",
" - Implement Stage 2 LoRA fine-tuning\n",
"\n",
"4. **Integrate with LLM generation**:\n",
" - Replace retrieval-based inference with actual LLM generation\n",
" - Inject bio tokens into prompts\n",
" - Use instruction-tuned LLM for reasoning\n",
"\n",
"5. **Evaluate on benchmarks**:\n",
" - Mol-Instructions tasks\n",
" - scEval PBMC10K\n",
" - Use LLM-as-judge, BERTScore, ROUGE-L\n",
"\n",
"### Code is Modular and Extensible:\n",
"\n",
"- `ProjectionLayer`: Drop-in replacement for any BioFM → LLM alignment\n",
"- `AutoregressiveAlignmentLoss` / `ContrastiveAlignmentLoss`: Can be used with any paired embeddings\n",
"- Training loops: Standard PyTorch patterns, easily adaptable\n",
"\n",
"### Resources:\n",
"\n",
"- **Paper**: arXiv:2510.01428\n",
"- **Related work**: CLIP, BLIP-2, LLaVA, InternVL for vision-language inspiration\n",
"- **Datasets**: UniProtKB, LLASmol, CellxGene, Mol-Instructions, scEval\n",
"- **Models**: scGPT, ESM-2, ChemBERTa, MAMMAL, Granite-8B\n",
"\n",
"---\n",
"\n",
"**End of Notebook**"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"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.10.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment