From 4b95e5653d1ed723546591c7bb4ed95b9672855b Mon Sep 17 00:00:00 2001 From: Umberto Lupo Date: Wed, 15 May 2024 15:15:28 +0200 Subject: [PATCH 1/2] Fix #11 Add simple graph alignment notebook to showcase `GraphAlignment` and greedy bootstrapped optimization using `n_repeats` --- README.md | 36 +- nbs/index.ipynb | 10 +- nbs/tutorials/graph_alignment.ipynb | 323 ++++++++++++++++++ .../mutual_information_msa_pairing.ipynb | 4 +- 4 files changed, 354 insertions(+), 19 deletions(-) create mode 100644 nbs/tutorials/graph_alignment.ipynb diff --git a/README.md b/README.md index 89c84fc..7453e61 100644 --- a/README.md +++ b/README.md @@ -120,7 +120,7 @@ python -m pip install -e . ## Quickstart -### Input data preprocessing +### Input data preprocessing (MSA pairing) First, parse your multiple sequence alignments (MSAs) in FASTA format into a list of tuples `(header, sequence)` using @@ -205,21 +205,28 @@ msa_B_oh = one_hot_encode_msa(msa_B_for_pairing, device=device) ### Pairing optimization -Finally, we can instantiate an +Finally, we can instantiate a class from `diffpass.train` to find an +optimal pairing between `x` and `y`. Here, `x` and `y` are MSAs, so we +can look for a pairing that optimizes the mutual information between `x` +and `y`. For this, we use [`InformationPairing`](https://Bitbol-Lab.github.io/DiffPaSS/train.html#informationpairing) -object and optimize the mutual information between the paired MSAs using -the DiffPaSS bootstrapped optimization algorithm. The results are stored -in a -[`DiffPaSSResults`](https://Bitbol-Lab.github.io/DiffPaSS/base.html#diffpassresults) -container. The lists of (hard) losses and permutations found during the -optimization can be accessed as attributes of the container. +and the DiffPaSS bootstrapped optimization algorithm. See the tutorials +below for other examples, including for graph alignment when `x` and `y` +are weighted adjacency matrices. ``` python from diffpass.train import InformationPairing information_pairing = InformationPairing(group_sizes=species_sizes).to(device) bootstrap_results = information_pairing.fit_bootstrap(x, y) +``` +The results are stored in a +[`DiffPaSSResults`](https://Bitbol-Lab.github.io/DiffPaSS/base.html#diffpassresults) +container. The lists of (hard) losses and permutations found during the +optimization can be accessed as attributes of the container: + +``` python print(f"Final hard loss: {bootstrap_results.hard_losses[-1].item()}") print(f"Final hard permutations (one permutation per species): {bootstrap_results.hard_perms[-1][-1].item()}") ``` @@ -229,11 +236,14 @@ the tutorials. ## Tutorials -See the -[`mutual_information_msa_pairing.ipynb`](https://github.com/Bitbol-Lab/DiffPaSS/blob/main/nbs/tutorials/mutual_information_msa_pairing.ipynb) -notebook for an example of paired MSA optimization in the case of -well-known prokaryotic datasets, for which ground truth pairings are -given by genome proximity. +- [`mutual_information_msa_pairing.ipynb`](https://github.com/Bitbol-Lab/DiffPaSS/blob/main/nbs/tutorials/mutual_information_msa_pairing.ipynb): + paired MSA optimization using mutual information in the case of + well-known prokaryotic datasets, for which ground truth pairings are + given by genome proximity. +- [`graph_alignment.ipynb`](https://github.com/Bitbol-Lab/DiffPaSS/blob/main/nbs/tutorials/graph_alignment.ipynb): + general graph alignment using + [`diffpass.train.GraphAlignment`](https://Bitbol-Lab.github.io/DiffPaSS/train.html#graphalignment), + with an example of aligning two weighted adjacency matrices. ## Documentation diff --git a/nbs/index.ipynb b/nbs/index.ipynb index 03590ac..8d8be68 100644 --- a/nbs/index.ipynb +++ b/nbs/index.ipynb @@ -91,7 +91,7 @@ "source": [ "## Quickstart\n", "\n", - "### Input data preprocessing\n", + "### Input data preprocessing (MSA pairing)\n", "\n", "First, parse your multiple sequence alignments (MSAs) in FASTA format into a list of tuples ``(header, sequence)`` using `read_msa`.\n", "\n", @@ -164,14 +164,17 @@ "\n", "### Pairing optimization\n", "\n", - "Finally, we can instantiate an `InformationPairing` object and optimize the mutual information between the paired MSAs using the DiffPaSS bootstrapped optimization algorithm. The results are stored in a `DiffPaSSResults` container. The lists of (hard) losses and permutations found during the optimization can be accessed as attributes of the container.\n", + "Finally, we can instantiate a class from `diffpass.train` to find an optimal pairing between `x` and `y`. Here, `x` and `y` are MSAs, so we can look for a pairing that optimizes the mutual information between `x` and `y`. For this, we use `InformationPairing` and the DiffPaSS bootstrapped optimization algorithm. See the tutorials below for other examples, including for graph alignment when `x` and `y` are weighted adjacency matrices.\n", "\n", "```python\n", "from diffpass.train import InformationPairing\n", "\n", "information_pairing = InformationPairing(group_sizes=species_sizes).to(device)\n", "bootstrap_results = information_pairing.fit_bootstrap(x, y)\n", + "```\n", "\n", + "The results are stored in a `DiffPaSSResults` container. The lists of (hard) losses and permutations found during the optimization can be accessed as attributes of the container:\n", + "```python\n", "print(f\"Final hard loss: {bootstrap_results.hard_losses[-1].item()}\")\n", "print(f\"Final hard permutations (one permutation per species): {bootstrap_results.hard_perms[-1][-1].item()}\")\n", "```\n", @@ -185,7 +188,8 @@ "source": [ "## Tutorials\n", "\n", - "See the [`mutual_information_msa_pairing.ipynb`](https://github.com/Bitbol-Lab/DiffPaSS/blob/main/nbs/tutorials/mutual_information_msa_pairing.ipynb) notebook for an example of paired MSA optimization in the case of well-known prokaryotic datasets, for which ground truth pairings are given by genome proximity." + "- [`mutual_information_msa_pairing.ipynb`](https://github.com/Bitbol-Lab/DiffPaSS/blob/main/nbs/tutorials/mutual_information_msa_pairing.ipynb): paired MSA optimization using mutual information in the case of well-known prokaryotic datasets, for which ground truth pairings are given by genome proximity.\n", + "- [`graph_alignment.ipynb`](https://github.com/Bitbol-Lab/DiffPaSS/blob/main/nbs/tutorials/graph_alignment.ipynb): general graph alignment using `diffpass.train.GraphAlignment`, with an example of aligning two weighted adjacency matrices." ] }, { diff --git a/nbs/tutorials/graph_alignment.ipynb b/nbs/tutorials/graph_alignment.ipynb new file mode 100644 index 0000000..7e9df1b --- /dev/null +++ b/nbs/tutorials/graph_alignment.ipynb @@ -0,0 +1,323 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DiffPaSS – Graph alignment\n", + "\n", + "> Using DiffPaSS to align two graphs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "**Note**: This notebook requires `networkx`." + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n" + ] + } + ], + "source": [ + "# Stdlib imports\n", + "from typing import Optional\n", + "\n", + "# NumPy\n", + "import numpy as np\n", + "\n", + "# PyTorch\n", + "import torch\n", + "\n", + "# Plotting\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# NetworkX\n", + "import networkx as nx\n", + "\n", + "# Set the number of threads for PyTorch\n", + "torch.set_num_threads(8)\n", + "\n", + "# Device\n", + "DEVICE = torch.device(\n", + " f\"cuda{(':' + input('Enter the CUDA device number:')) if torch.cuda.device_count() > 1 else ''}\"\n", + " if torch.cuda.is_available() else \"cpu\"\n", + ")\n", + "# DEVICE = torch.device(\"cpu\")\n", + "print(f\"Using device: {DEVICE}\")\n", + "\n", + "# Set the seeds for NumPy and PyTorch\n", + "NUMPY_SEED = 42\n", + "np.random.seed(NUMPY_SEED)\n", + "\n", + "TORCH_SEED = 42\n", + "torch.manual_seed(TORCH_SEED);\n", + "\n", + "NX_SEED = 42" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Create the adjacency matrices of two SBM graphs\n", + "\n", + "We create two SBM graphs with a few communities of equal size. We then randomly permute the nodes in one of the graphs to create the second graph. The Laplacian matrices of these graphs are used as inputs for `diffpass.train.GraphAlignment`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def create_test_sbm_laplacian(\n", + " block_sizes: list ,\n", + " block_prob: list,\n", + "):\n", + " \"\"\"Create a stochastic block model graph with given block sizes and block probabilities. Return its dense Laplacian matrix.\"\"\"\n", + " g = nx.stochastic_block_model(block_sizes, block_prob, seed=NX_SEED)\n", + " g.remove_nodes_from(list(nx.isolates(g)))\n", + " n = len(g)\n", + " # Laplacian matrix\n", + " l = nx.laplacian_matrix(g, range(n))\n", + "\n", + " return torch.tensor(\n", + " l.todense(), dtype=torch.get_default_dtype(), device=DEVICE\n", + " )\n", + "\n", + "# Create an SBM graph with `n_blocks` communities of equal size\n", + "n_nodes = 40\n", + "n_blocks = 4\n", + "block_sizes = [int(n_nodes / n_blocks)] * n_blocks\n", + "inter = 0.3\n", + "intra = 0.7\n", + "probs = [\n", + " [intra, inter, inter, inter],\n", + " [inter, intra, inter, inter],\n", + " [inter, inter, intra, inter],\n", + " [inter, inter, inter, intra]\n", + "]\n", + "\n", + "# Create the Laplacian matrix of the first graph\n", + "x = create_test_sbm_laplacian(block_sizes, probs)\n", + "\n", + "# Define the second graph by randomly permuting the nodes in the first\n", + "P = torch.zeros_like(x)\n", + "P[torch.arange(n_nodes), torch.randperm(n_nodes)] = 1\n", + "y = P @ x @ P.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Align the graphs by maximising the dot product between the Laplacian matrices: `GraphAlignment`\n", + "\n", + "The default behaviour of `GraphAlignment` is to maximise the dot product between the upper triangles (including or excluding the main diagonal) of two input square matrices. The `GraphAlignment` class also allows for custom comparison losses to be used, but we do not do so in this example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from diffpass.train import GraphAlignment, IntraGroupSimilarityLoss\n", + "\n", + "group_sizes = [n_nodes]\n", + "comparison_loss = IntraGroupSimilarityLoss(group_sizes=group_sizes, exclude_diagonal=False) # Default behaviour except for inclusion of the main diagonal\n", + "\n", + "# Initialize the GraphAlignment model\n", + "graph_alignment = GraphAlignment(\n", + " group_sizes=group_sizes,\n", + " comparison_loss=comparison_loss\n", + ").to(DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 38/38 [00:00<00:00, 252.12it/s]\n" + ] + } + ], + "source": [ + "# Optimization parameters for DiffPaSS bootstrap\n", + "bootstrap_cfg = {\n", + " \"n_start\": 1,\n", + " \"n_end\": None,\n", + " \"step_size\": 1, # Increase to speed up if needed\n", + " \"show_pbar\": True,\n", + " \"single_fit_cfg\": None # Default\n", + "}\n", + "\n", + "# Run the DiffPaSS bootstrap\n", + "bootstrap_results = graph_alignment.fit_bootstrap(x, y, **bootstrap_cfg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## 3. Plot the resulting hard losses" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Ground truth hard loss\n", + "target_hard_loss = graph_alignment.compute_losses_identity_perm(x, x)[\"hard\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from diffpass.data_utils import compute_num_correct_pairings\n", + "\n", + "def plot_hard_losses(\n", + " results,\n", + " target_hard_loss: Optional[float] = None\n", + "):\n", + " hard_losses = [\n", + " min(hard_losses_this_step)\n", + " for hard_losses_this_step in results.hard_losses\n", + " ]\n", + "\n", + " plt.plot(hard_losses, \".-\", label=\"DiffPaSS hard permutation\")\n", + " plt.axhline(target_hard_loss, color=\"red\", label=f\"Ground truth loss (identity) = {target_hard_loss:.4f}\")\n", + " plt.ylabel(\"Hard loss\")\n", + " plt.xlabel(\"Bootstrap iteration\")\n", + " plt.title(f\"Minimum loss during optimization: {np.min(hard_losses):.4f}\")\n", + " plt.legend()\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": "plot_hard_losses(bootstrap_results, target_hard_loss=target_hard_loss)" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The hard loss has been decreased, but is a far cry from the ground truth loss.\n", + "\n", + "Can we do better?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Increase the number of repeats for each bootstrap iteration\n", + "\n", + "We can use a \"greedier\" approach and further exploit the randomness in the bootstrap procedure. At each bootstrap iteration, instead of only performing a single gradient optimization, we can perform multiple optimizations -- each using a different, randomly sampled set of fixed pairs. We can then choose the one yielding the lowest hard loss.\n", + "\n", + "This is done by setting `n_repeats` to a value greater than 1 in the `fit_bootstrap` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 38/38 [00:13<00:00, 2.89it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bootstrap_cfg = {\n", + " \"n_start\": 1,\n", + " \"n_end\": None,\n", + " \"step_size\": 1, # Increase to speed up if needed\n", + " \"show_pbar\": True,\n", + " \"single_fit_cfg\": None, # Default\n", + " \"n_repeats\": 100 # Number of repeats for each bootstrap iteration -- increasing this should lead to better results\n", + "}\n", + "\n", + "graph_alignment = GraphAlignment(\n", + " group_sizes=group_sizes,\n", + " comparison_loss=comparison_loss\n", + ").to(DEVICE)\n", + "\n", + "bootstrap_results = graph_alignment.fit_bootstrap(x, y, **bootstrap_cfg)\n", + "\n", + "plot_hard_losses(bootstrap_results, target_hard_loss=target_hard_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "Awesome! We have perfectly matched the hard loss given by the ground truth alignment!" + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/nbs/tutorials/mutual_information_msa_pairing.ipynb b/nbs/tutorials/mutual_information_msa_pairing.ipynb index d5be9e8..46bad69 100644 --- a/nbs/tutorials/mutual_information_msa_pairing.ipynb +++ b/nbs/tutorials/mutual_information_msa_pairing.ipynb @@ -180,9 +180,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## 3. Optimize pairings by maximising mutual information between chains: ``InformationAlignment``" - ] + "source": "## 3. Optimize pairings by maximising mutual information between chains: `InformationAlignment`" }, { "cell_type": "code", From 858b0f624f0d5379855fd4116edb64df50262736 Mon Sep 17 00:00:00 2001 From: Umberto Lupo Date: Wed, 15 May 2024 15:16:11 +0200 Subject: [PATCH 2/2] Include notebook in sidebar --- nbs/sidebar.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/nbs/sidebar.yml b/nbs/sidebar.yml index 657fa01..89fba9b 100644 --- a/nbs/sidebar.yml +++ b/nbs/sidebar.yml @@ -14,4 +14,5 @@ website: - train.ipynb - section: tutorials contents: + - tutorials/graph_alignment.ipynb - tutorials/mutual_information_msa_pairing.ipynb