EBI_Interview_Report.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "id": "8a07d271-2def-4a8c-bd17-bc47d294fbb1",
   "metadata": {},
   "source": [
    "---\n",
    "title: \"EBI-EMBL - Internship Technical Interview : Coding Challenge\"\n",
    "author: \"Philippe Stocker, Master's Student in Bioinformatics Modelling and Statistics\"\n",
    "date: \"2023-12-08\"\n",
    "subtitle: \"Comparison of Full Jaccard k-mer and MinHash-based Distances\"\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "7191651a-f382-4f52-9d93-dae78260f484",
   "metadata": {},
   "outputs": [],
   "source": [
    "import hashlib\n",
    "import numpy as np\n",
    "import csv\n",
    "from Bio import SeqIO\n",
    "import matplotlib.pyplot as plt\n",
    "from Bio import Phylo\n",
    "from io import StringIO\n",
    "import pandas as pd\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cce34bed",
   "metadata": {},
   "source": [
    "\n",
    "### Step 1: Load genome sequences and extract k-mers\n",
    "This step involves reading the genome sequences from FASTA files and extracting all possible 14-mers.\n",
    "\n",
    "**Functions**:\n",
    "- `load_fasta`: Loads the genome sequences from a FASTA file.\n",
    "- `extract_kmers`: Extracts unique k-mers of a specified length from a sequence.\n",
    "\n",
    "**Input**:\n",
    "- Genome FASTA file.\n",
    "\n",
    "**Output**:\n",
    "- Concatenated genome sequence (string).\n",
    "- Set of unique 14-mers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0aaf8186-67cf-4229-a86e-b7b4a0878f00",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_fasta(file_path):\n",
    "    sequences = []\n",
    "    for record in SeqIO.parse(file_path, \"fasta\"):\n",
    "        sequences.append(str(record.seq))\n",
    "    concatenated_sequence = \"\".join(sequences)\n",
    "    return concatenated_sequence\n",
    "\n",
    "def extract_kmers(sequence, k=14):\n",
    "    return {sequence[i:i+k] for i in range(len(sequence) - k + 1)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1b8c348c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded sequence (first 100 bases): TTGAAAGAAAAACAATTTTGGAATCGTATATTAGAATTTGCACAAGAAAGACTGACTCGATCCATGTATGATTTCTATGCTATTCAAGCTGAACTTATCA\n",
      "Extracted 1952351 unique 14-mers (sample): ['TGTAGTACAAACTC', 'ATCTTTTCCAGACG', 'ATCTTTTGGATTTG', 'TAGAAACCCAATAG', 'TTCTATTATAGACG']\n"
     ]
    }
   ],
   "source": [
    "# Test Step 1\n",
    "file_path = \"R6.fa\"  # Example file path\n",
    "sequence = load_fasta(file_path)\n",
    "print(f\"Loaded sequence (first 100 bases): {sequence[:100]}\")\n",
    "\n",
    "kmers = extract_kmers(sequence, k=14)\n",
    "print(f\"Extracted {len(kmers)} unique 14-mers (sample): {list(kmers)[:5]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1469fd2",
   "metadata": {},
   "source": [
    "\n",
    "### Step 2: Generate MinHash sketches\n",
    "This step generates MinHash sketches for each genome by hashing the k-mers and selecting the smallest hashes.\n",
    "\n",
    "**Functions**:\n",
    "- `hash_kmer`: Hashes a k-mer and its reverse complement to get the canonical hash.\n",
    "- `minhash_sketch`: Creates a MinHash sketch of specified size and optionally saves it to a file.\n",
    "\n",
    "**Input**:\n",
    "- Set of k-mers.\n",
    "\n",
    "**Output**:\n",
    "- MinHash sketch (list of integers).\n",
    "- Saved sketch file (optional).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1edbf615-2e6b-409d-9688-f195ec51eb4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hash_kmer(kmer):\n",
    "    reverse_comp = kmer[::-1].translate(str.maketrans(\"ACGT\", \"TGCA\"))\n",
    "    return min(int(hashlib.md5(kmer.encode()).hexdigest(), 16),\n",
    "               int(hashlib.md5(reverse_comp.encode()).hexdigest(), 16))\n",
    "\n",
    "def minhash_sketch(kmers, sketch_size=1000, genome_name=None, save_sketch=False):\n",
    "    \"\"\"\n",
    "    Generate a MinHash sketch of a specified size and optionally save it to a file.\n",
    "\n",
    "    Args:\n",
    "        kmers (set of str): Set of k-mers to hash.\n",
    "        sketch_size (int): Number of lowest hash values to include in the sketch.\n",
    "        genome_name (str): Name of the genome (used for file naming).\n",
    "        save_sketch (bool): If True, save the sketch to a file.\n",
    "\n",
    "    Returns:\n",
    "        list: MinHash sketch (list of lowest hash values).\n",
    "    \"\"\"\n",
    "    hashes = {hash_kmer(kmer) for kmer in kmers}\n",
    "    sketch = sorted(hashes)[:sketch_size]\n",
    "\n",
    "    if save_sketch and genome_name:\n",
    "        file_name = f\"{genome_name}_sketch.txt\"\n",
    "        with open(file_name, \"w\") as f:\n",
    "            for hash_value in sketch:\n",
    "                f.write(f\"{hash_value}\\n\")\n",
    "        print(f\"Sketch saved to {file_name}\")\n",
    "\n",
    "    return sketch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa4e6ad4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test Step 2\n",
    "sketch = minhash_sketch(kmers, sketch_size=1000, genome_name=\"R6\", save_sketch=True)\n",
    "print(f\"Generated MinHash sketch (sample): {sketch[:5]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94026fcf",
   "metadata": {},
   "source": [
    "### Step 3: Calculate pairwise MinHash distances\n",
    "This step calculates the Jaccard distance between the MinHash sketches of different genomes.\n",
    "\n",
    "**Functions**:\n",
    "- `minhash_distance`: Computes the Jaccard distance between two MinHash sketches.\n",
    "\n",
    "**Input**:\n",
    "- MinHash sketches of two genomes.\n",
    "\n",
    "**Output**:\n",
    "- Jaccard distance (float).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "58fa11e3-e326-4958-87e0-a555fabd2f9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def minhash_distance(sketch_a, sketch_b):\n",
    "    set_a, set_b = set(sketch_a), set(sketch_b)\n",
    "    intersection = len(set_a & set_b)\n",
    "    union = len(set_a | set_b)\n",
    "    return 1 - (intersection / union)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0bc147dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculated MinHash distance: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Test Step 3\n",
    "sketch_a = minhash_sketch(kmers, sketch_size=1000)\n",
    "sketch_b = minhash_sketch(kmers, sketch_size=1000)  # Reuse for testing\n",
    "distance = minhash_distance(sketch_a, sketch_b)\n",
    "print(f\"Calculated MinHash distance: {distance}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd921b53",
   "metadata": {},
   "source": [
    "\n",
    "### Step 4: Construct the distance matrix\n",
    "This step generates a pairwise distance matrix from the computed MinHash distances.\n",
    "\n",
    "**Functions**:\n",
    "- `construct_distance_matrix`: Builds the distance matrix and optionally saves it to a file.\n",
    "\n",
    "**Input**:\n",
    "- List of genome names.\n",
    "- Pairwise MinHash distances.\n",
    "\n",
    "**Output**:\n",
    "- Symmetric distance matrix (numpy array).\n",
    "- Saved distance matrix file.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "dda004f8-765d-4f01-b6a2-baea8d86e6a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def construct_distance_matrix(labels, distances, display_graphical=False, output_path=\"pairwise_distance_matrix.txt\"):\n",
    "    \"\"\"\n",
    "    Construct a square distance matrix from pairwise distances, optionally display it graphically,\n",
    "    and save it to a text file.\n",
    "\n",
    "    Args:\n",
    "        labels (list of str): Names of the sequences.\n",
    "        distances (dict): Pairwise distances as {(label_a, label_b): distance}.\n",
    "        display_graphical (bool): If True, print the distance matrix as a table.\n",
    "        output_path (str): Path to save the distance matrix as a text file.\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: Symmetric distance matrix.\n",
    "    \"\"\"\n",
    "    size = len(labels)\n",
    "    matrix = np.zeros((size, size))\n",
    "    label_to_index = {label: idx for idx, label in enumerate(labels)}\n",
    "\n",
    "    # Populate the matrix\n",
    "    for (label_a, label_b), distance in distances.items():\n",
    "        i, j = label_to_index[label_a], label_to_index[label_b]\n",
    "        matrix[i, j] = distance\n",
    "        matrix[j, i] = distance\n",
    "\n",
    "    # Prepare the graphical output\n",
    "    header = \"\\t\" + \"\\t\".join(labels)\n",
    "    rows = [f\"{labels[i]}\\t\" + \"\\t\".join(f\"{matrix[i, j]:.4f}\" for j in range(size)) for i in range(size)]\n",
    "    graphical_output = header + \"\\n\" + \"\\n\".join(rows)\n",
    "\n",
    "    # Display the graphical representation\n",
    "    if display_graphical:\n",
    "        print(\"Distance Matrix (Graphical Representation):\")\n",
    "        print(graphical_output)\n",
    "\n",
    "    # Save the distance matrix to a text file\n",
    "    with open(output_path, \"w\") as f:\n",
    "        f.write(graphical_output)\n",
    "    print(f\"Distance matrix saved to {output_path}\")\n",
    "\n",
    "    return matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "e2609a20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance Matrix (Graphical Representation):\n",
      "\tR6.fa\tTIGR4.fa\n",
      "R6.fa\t0.0000\t0.2500\n",
      "TIGR4.fa\t0.2500\t0.0000\n",
      "Distance matrix saved to pairwise_distance_matrix.txt\n",
      "Distance matrix: [[0.   0.25]\n",
      " [0.25 0.  ]]\n"
     ]
    }
   ],
   "source": [
    "# Test Step 4\n",
    "genome_files = [\"R6.fa\", \"TIGR4.fa\"]  # Example genome files\n",
    "distances = {(\"R6.fa\", \"TIGR4.fa\"): 0.25}  # Example distance\n",
    "matrix = construct_distance_matrix(genome_files, distances, display_graphical=True)\n",
    "print(\"Distance matrix:\", matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6514c646",
   "metadata": {},
   "source": [
    "\n",
    "### Step 5: Infer the phylogenetic tree\n",
    "This step infers the phylogenetic tree using the Neighbor-Joining algorithm.\n",
    "\n",
    "**Functions**:\n",
    "- `doNeighbourJoining`: Infers the tree in Newick format from the distance matrix.\n",
    "- `save_newick`: Saves the Newick tree to a file.\n",
    "- `plot_tree_from_newick`: Plots the phylogenetic tree and saves it as an image.\n",
    "\n",
    "**Input**:\n",
    "- Distance matrix.\n",
    "- Genome names.\n",
    "\n",
    "**Output**:\n",
    "- Newick tree string.\n",
    "- Saved tree file.\n",
    "- Saved tree plot.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6f4897f-21c3-4e05-b7e6-e7f734020741",
   "metadata": {},
   "source": [
    "To implement **neighbour-joining** I use functions from : https://github.com/sness/courses/blob/master/neighbour-joining.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "68eef23e-4a8c-4569-b0f7-102a07979ccf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculateQ(d):\n",
    "    r = d.shape[0]\n",
    "    q = np.zeros((r, r))\n",
    "    for i in range(r):\n",
    "        for j in range(r):\n",
    "            if i != j:\n",
    "                sumI = np.sum(d[i, :])\n",
    "                sumJ = np.sum(d[j, :])\n",
    "                q[i, j] = (r - 2) * d[i, j] - sumI - sumJ\n",
    "    return q\n",
    "\n",
    "def findLowestPair(q):\n",
    "    minVal = np.inf\n",
    "    minIndex = (0, 0)\n",
    "    for i in range(q.shape[0]):\n",
    "        for j in range(i + 1, q.shape[0]):\n",
    "            if q[i, j] < minVal:\n",
    "                minVal = q[i, j]\n",
    "                minIndex = (i, j)\n",
    "    return minIndex\n",
    "\n",
    "def calculateNewDistanceMatrix(f, g, d):\n",
    "    r = d.shape[0]\n",
    "    indices = [i for i in range(r) if i != f and i != g]\n",
    "    new_d = np.zeros((r - 1, r - 1))\n",
    "    for i, ii in enumerate(indices):\n",
    "        for j, jj in enumerate(indices):\n",
    "            new_d[i + 1, j + 1] = d[ii, jj]\n",
    "    for i, ii in enumerate(indices):\n",
    "        new_distance = (d[f, ii] + d[g, ii] - d[f, g]) / 2\n",
    "        new_d[0, i + 1] = new_distance\n",
    "        new_d[i + 1, 0] = new_distance\n",
    "    new_d[0, 0] = 0\n",
    "    return new_d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97e007f8-0157-4147-9e79-4c04d6068a8a",
   "metadata": {},
   "source": [
    "Then, I based on the Newick phylogeny format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "89ce5e04-8ba8-49d2-8f5f-4376c4b56697",
   "metadata": {},
   "outputs": [],
   "source": [
    "def doNeighbourJoining(d, labels):\n",
    "    \"\"\"\n",
    "    Perform the Neighbor-Joining algorithm to build a phylogenetic tree.\n",
    "\n",
    "    Args:\n",
    "        d (np.ndarray): Distance matrix.\n",
    "        labels (list): List of labels corresponding to rows/columns of the distance matrix.\n",
    "\n",
    "    Returns:\n",
    "        str: Newick-formatted string representing the tree.\n",
    "    \"\"\"\n",
    "    while len(labels) > 2:\n",
    "        # Step 1: Compute Q-matrix\n",
    "        q = calculateQ(d)\n",
    "        \n",
    "        # Step 2: Find the pair with the smallest Q-value\n",
    "        i, j = findLowestPair(q)\n",
    "        \n",
    "        # Step 3: Compute the distance to the new node\n",
    "        r = d.shape[0]\n",
    "        sumI = np.sum(d[i, :])\n",
    "        sumJ = np.sum(d[j, :])\n",
    "        distToNewNode = (d[i, j] + (sumI - sumJ) / (r - 2)) / 2\n",
    "        \n",
    "        # Step 4: Update labels\n",
    "        new_label = f\"({labels[i]}:{distToNewNode:.4f},{labels[j]}:{distToNewNode:.4f})\"\n",
    "        labels[i] = new_label\n",
    "        labels.pop(j)\n",
    "        \n",
    "        # Step 5: Update distance matrix\n",
    "        d = calculateNewDistanceMatrix(i, j, d)\n",
    "\n",
    "    # Final step: Combine the last two labels\n",
    "    tree = f\"({labels[0]}:{d[0, 1]:.4f},{labels[1]}:{d[0, 1]:.4f});\"\n",
    "    return tree\n",
    "\n",
    "\n",
    "def save_newick(tree, output_path=\"tree.nwk\"):\n",
    "    with open(output_path, \"w\") as f:\n",
    "        f.write(tree)\n",
    "    print(f\"Newick tree saved to {output_path}\")\n",
    "\n",
    "def plot_tree_from_newick(newick_path, output_path=\"tree.png\"):\n",
    "    with open(newick_path, \"r\") as f:\n",
    "        tree = Phylo.read(f, \"newick\")\n",
    "    fig = plt.figure(figsize=(10, 6))\n",
    "    ax = fig.add_subplot(1, 1, 1)\n",
    "    Phylo.draw(tree, axes=ax, do_show=False)\n",
    "    plt.savefig(output_path)\n",
    "    print(f\"Tree plotted and saved as {output_path}\")\n",
    "    plt.close(fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "bf961540",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated tree (Newick format): (14412_3#82.contigs_velvet.fa:0.2500,14412_3#84.contigs_velvet.fa:0.2500);\n",
      "Newick tree saved to test_tree.nwk\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test Step 5\n",
    "tree = doNeighbourJoining(matrix, genome_files)\n",
    "print(f\"Generated tree (Newick format): {tree}\")\n",
    "\n",
    "save_newick(tree, \"test_tree.nwk\")\n",
    "\n",
    "# Plot the tree inline\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "with open(\"test_tree.nwk\", \"r\") as f:\n",
    "    phylo_tree = Phylo.read(f, \"newick\")\n",
    "\n",
    "Phylo.draw(phylo_tree, axes=ax)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "475b28e7",
   "metadata": {},
   "source": [
    "### Step 6: Compare full distances vs. MinHash distances\r\n",
    "This step compares the Jaccard distances from the full k-mer set with the MinHash-based distances for accuracy and efficiency.\r\n",
    "\r\n",
    "**Functions**:\r\n",
    "- `minhash_distance`: Reused to calculate MinHash distances for different sketch sizes.\r\n",
    "- `full_distance`: Calculate distances for different k-mers sizes.\r\n",
    "\r\n",
    "**Input**:\r\n",
    "- Full k-mer Jaccard distances.\r\n",
    "- MinHash distances.\r\n",
    "\r\n",
    "**Output**:\r\n",
    "- Comparin:\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "33781345-200f-4f0e-a1f6-6859aeb2d369",
   "metadata": {},
   "outputs": [],
   "source": [
    "def full_distance(kmers_a, kmers_b):\n",
    "    \"\"\"\n",
    "    Calculate the full Jaccard distance between two sets of k-mers.\n",
    "\n",
    "    Args:\n",
    "        kmers_a (set): Set of k-mers from genome A.\n",
    "        kmers_b (set): Set of k-mers from genome B.\n",
    "\n",
    "    Returns:\n",
    "        float: Jaccard distance between the two sets.\n",
    "    \"\"\"\n",
    "    set_a, set_b = set(kmers_a), set(kmers_b)\n",
    "    intersection = len(set_a & set_b)\n",
    "    union = len(set_a | set_b)\n",
    "    return 1 - (intersection / union)\n",
    "\n",
    "def minhash_distance(sketch_a, sketch_b):\n",
    "    set_a, set_b = set(sketch_a), set(sketch_b)\n",
    "    intersection = len(set_a & set_b)\n",
    "    union = len(set_a | set_b)\n",
    "    return 1 - (intersection / union)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "91d56dd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full Jaccard Distance: 0.4444444444444444\n",
      "MinHash Jaccard Distance (sketch size 5): 0.5714285714285714\n"
     ]
    }
   ],
   "source": [
    "# Define the sequences and their k-mers\n",
    "# Same as in the Challenge example: \n",
    "sequence_a_kmers = {\n",
    "    \"TTGAAAGAAAAACA\", \"TGAAAGAAAAACAA\", \"GAAAGAAAAACAAT\", \"AAAGAAAAACAATT\",\n",
    "    \"AAGAAAAACAATTT\", \"AGAAAAACAATTTT\", \"GAAAAACAATTTTG\"\n",
    "}\n",
    "\n",
    "sequence_b_kmers = {\n",
    "    \"TTGAAAGAAAAACA\", \"TGAAAGAAAAACAA\", \"GAAAGAAAAACAAT\", \"AAAGAAAAACAATT\",\n",
    "    \"GAAAAACAATTTTG\", \"CTCGATCCATGTAT\", \"TCGATCCATGTATG\"\n",
    "}\n",
    "\n",
    "# Calculate Full Jaccard Distance\n",
    "full_jaccard_distance = full_distance(sequence_a_kmers, sequence_b_kmers)\n",
    "print(f\"Full Jaccard Distance: {full_jaccard_distance}\")\n",
    "\n",
    "# Generate MinHash sketches\n",
    "sketch_a = minhash_sketch(sequence_a_kmers, sketch_size=5)\n",
    "sketch_b = minhash_sketch(sequence_b_kmers, sketch_size=5)\n",
    "\n",
    "# Calculate MinHash Jaccard Distance\n",
    "minhash_jaccard_distance = minhash_distance(sketch_a, sketch_b)\n",
    "print(f\"MinHash Jaccard Distance (sketch size 5): {minhash_jaccard_distance}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc5d5da8-1467-43c8-8729-588a8c23363d",
   "metadata": {},
   "source": [
    "### Step 7: Analyze the impact of sketch size on distances\n",
    "This step evaluates how changing the sketch size impacts the MinHash-based distances.\n",
    "\n",
    "**Functions**:\n",
    "- `minhash_sketch`: Reused to create sketches with different sizes.\n",
    "- `minhash_distance`: Used to calculate distances for each sketch size.\n",
    "\n",
    "**Input**:\n",
    "- Set of k-mers.\n",
    "- Sketch sizes.\n",
    "\n",
    "**Output**:\n",
    "- Distance changes across sketch sizes.\n",
    "- A plot showing the relationship between sketch size and MinHash distance stability.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "cc29c841-7ead-4658-a37e-b9e7402f0b46",
   "metadata": {},
   "outputs": [],
   "source": [
    "def minhash_sketch(kmers, sketch_size=1000, genome_name=None, save_sketch=False):\r\n",
    "    \"\"\"\r\n",
    "    Generate a MinHash sketch of a specified size and optionally save it to a file.\r\n",
    "\r\n",
    "    Args:\r\n",
    "        kmers (set of str): Set of k-mers to hash.\r\n",
    "        sketch_size (int): Number of lowest hash values to include in the sketch.\r\n",
    "        genome_name (str): Name of the genome (used for file naming).\r\n",
    "        save_sketch (bool): If True, save the sketch to a file.\r\n",
    "\r\n",
    "    Returns:\r\n",
    "        list: MinHash sketch (list of lowest hash values).\r\n",
    "    \"\"\"\r\n",
    "    hashes = {hash_kmer(kmer) for kmer in kmers}\r\n",
    "    sketch = sorted(hashes)[:sketch_size]\r\n",
    "\r\n",
    "    if save_sketch and genome_name:\r\n",
    "        file_name = f\"{genome_name}_sketch.txt\"\r\n",
    "        with open(file_name, \"w\") as f:\r\n",
    "            for hash_value in sketch:\r\n",
    "                f.write(f\"{hash_value}\\n\")\r\n",
    "        print(f\"Sketch saved to {file_name}\")\r\n",
    "\r\n",
    "    return sketch\r\n",
    "\r\n",
    "\r\n",
    "def minhash_distance(sketch_a, sketch_b):\r\n",
    "    set_a, set_b = set(sketch_a), set(sketch_b)\r\n",
    "    intersection = len(set_a & set_b)\r\n",
    "    union = len(set_a | set_b)\r\n",
    "    return 1 - (intersection / union)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "760f9b6b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sketch size: 5, MinHash Jaccard Distance: 0.33333333333333337\n",
      "Sketch size: 10, MinHash Jaccard Distance: 0.33333333333333337\n",
      "Sketch size: 20, MinHash Jaccard Distance: 0.26086956521739135\n",
      "Sketch size: 50, MinHash Jaccard Distance: 0.2142857142857143\n",
      "Sketch size: 100, MinHash Jaccard Distance: 0.24561403508771928\n",
      "Sketch size: 200, MinHash Jaccard Distance: 0.23788546255506604\n",
      "Sketch size: 500, MinHash Jaccard Distance: 0.24561403508771928\n",
      "Sketch size: 1000, MinHash Jaccard Distance: 0.26238053866203304\n",
      "Sketch size: 2000, MinHash Jaccard Distance: 0.27288428324697755\n",
      "Sketch size: 5000, MinHash Jaccard Distance: 0.2701954679121259\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define genome files\n",
    "genome_files = [\"R6.fa\", \"TIGR4.fa\"]\n",
    "\n",
    "# Step 1: Load sequences and extract k-mers\n",
    "sequences = {file: load_fasta(file) for file in genome_files}\n",
    "kmers = {file: extract_kmers(seq, k=14) for file, seq in sequences.items()}\n",
    "\n",
    "sequence_a_kmers = kmers[\"R6.fa\"]\n",
    "sequence_b_kmers = kmers[\"TIGR4.fa\"]\n",
    "\n",
    "# Step 2: Define sketch sizes to test\n",
    "sketch_sizes = [5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000]\n",
    "\n",
    "# Initialize results\n",
    "results = []\n",
    "\n",
    "# Step 3: Calculate MinHash distances for each sketch size\n",
    "for sketch_size in sketch_sizes:\n",
    "    sketch_a = minhash_sketch(sequence_a_kmers, sketch_size=sketch_size)\n",
    "    sketch_b = minhash_sketch(sequence_b_kmers, sketch_size=sketch_size)\n",
    "    distance = minhash_distance(sketch_a, sketch_b)\n",
    "    results.append((sketch_size, distance))\n",
    "    print(f\"Sketch size: {sketch_size}, MinHash Jaccard Distance: {distance}\")\n",
    "\n",
    "# Step 4: Plot the impact of sketch size on distance\n",
    "sketch_sizes, distances = zip(*results)\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(sketch_sizes, distances, marker='o')\n",
    "plt.title(\"Impact of Sketch Size on MinHash Distance\")\n",
    "plt.xlabel(\"Sketch Size\")\n",
    "plt.ylabel(\"MinHash Jaccard Distance\")\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "726efec4-a253-458f-8b0d-aa71b629bc7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sketch size: 10, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 50, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 100, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 250, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 500, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 1000, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 2000, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 3000, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 4000, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n",
      "Sketch size: 5000, MinHash Jaccard Distance: 0.4444444444444444, Time Taken: 0.0000 seconds\n"
     ]
    }
   ],
   "source": [
    "# Step 2: Define sketch sizes to test\n",
    "sketch_sizes = [10, 50, 100, 250, 500, 1000, 2000, 3000, 4000, 5000]\n",
    "\n",
    "# Initialize results\n",
    "results = []\n",
    "\n",
    "# Step 3: Calculate MinHash distances for each sketch size and record time\n",
    "for sketch_size in sketch_sizes:\n",
    "    start_time = time.time()  # Record the start time\n",
    "    \n",
    "    # Generate MinHash sketches and compute distance\n",
    "    sketch_a = minhash_sketch(sequence_a_kmers, sketch_size=sketch_size)\n",
    "    sketch_b = minhash_sketch(sequence_b_kmers, sketch_size=sketch_size)\n",
    "    distance = minhash_distance(sketch_a, sketch_b)\n",
    "    \n",
    "    end_time = time.time()  # Record the end time\n",
    "    \n",
    "    # Compute elapsed time\n",
    "    elapsed_time = end_time - start_time\n",
    "    \n",
    "    # Append results and print with timestamp\n",
    "    results.append((sketch_size, distance, elapsed_time))\n",
    "    print(f\"Sketch size: {sketch_size}, MinHash Jaccard Distance: {distance}, Time Taken: {elapsed_time:.4f} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "d882cdc2-62e5-4463-b6c6-be4f6264acd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Unpack results into sketch sizes, distances, and times\n",
    "sketch_sizes, distances, times = zip(*results)\n",
    "\n",
    "# Create the plot\n",
    "fig, ax1 = plt.subplots(figsize=(10, 6))\n",
    "\n",
    "# Plot MinHash Jaccard distances on the primary y-axis\n",
    "ax1.plot(sketch_sizes, distances, marker='o', label='MinHash Jaccard Distance')\n",
    "ax1.set_xlabel(\"Sketch Size\")\n",
    "ax1.set_ylabel(\"MinHash Jaccard Distance\", color='blue')\n",
    "ax1.tick_params(axis='y', labelcolor='blue')\n",
    "\n",
    "# Create a secondary y-axis for computation time\n",
    "ax2 = ax1.twinx()\n",
    "ax2.plot(sketch_sizes, times, marker='o', color='red', label='Computation Time')\n",
    "ax2.set_ylabel(\"Computation Time (seconds)\", color='red')\n",
    "ax2.tick_params(axis='y', labelcolor='red')\n",
    "\n",
    "# Add grid and title\n",
    "fig.suptitle(\"Impact of Sketch Size on MinHash Distance and Computation Time\")\n",
    "ax1.grid()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d75dee1a-0cc0-4b40-a6f9-4555f7f3ab1c",
   "metadata": {},
   "source": [
    "### Step 8: Build neighbor-joining tree with different distances\r\n",
    "This step builds neighbor-joining trees using different distance measures (full k-mer Jaccard distance and MinHash-based Jaccard distance).\r\n",
    "\r\n",
    "**Functions**:\r\n",
    "- `full_distance`: Calculates the Jaccard distance between full k-mer sets.\r\n",
    "- `minhash_distance`: Approximates Jaccard distance using MinHash sketches.\r\n",
    "- `doNeighbourJoining`: Builds neighbor-joining trees using the distance matrices.\r\n",
    "\r\n",
    "**Input**:\r\n",
    "- Genome k-mers and their MinHash sketches.\r\n",
    "- Distance matrices from full k-mer and MinHash-based distances.\r\n",
    "\r\n",
    "**Output**:\r\n",
    "- Neighbor-joining trees for comparison."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74b3e2bf-fb54-4ae3-8ccf-2882f65d7700",
   "metadata": {},
   "source": [
    "**Inputs**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "351abcec-5ccd-479b-86ac-0449f361fa3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Genome files: ['R6.fa', 'TIGR4.fa', '14412_3#82.contigs_velvet.fa', '14412_3#84.contigs_velvet.fa']\n",
      "Kmers keys: ['R6.fa', 'TIGR4.fa', '14412_3#82.contigs_velvet.fa', '14412_3#84.contigs_velvet.fa']\n",
      "\n",
      "Method: Full Jaccard Distance\n",
      "Calculating pairwise distances...\n",
      "Distance matrix saved to pairwise_distance_matrix.txt\n",
      "Time for Full Jaccard Distance Matrix: 3.5381 seconds\n",
      "Full Jaccard Distance Matrix:\n",
      "[[0.         0.97436876 0.98867522 0.98870067]\n",
      " [0.97436876 0.         0.98845316 0.98848052]\n",
      " [0.98867522 0.98845316 0.         0.56082534]\n",
      " [0.98870067 0.98848052 0.56082534 0.        ]]\n",
      "\n",
      "Method: MinHash Jaccard Distance\n",
      "Generating MinHash sketches...\n",
      "Time for MinHash Sketches: 31.2722 seconds\n",
      "Calculating pairwise distances...\n",
      "Distance matrix saved to pairwise_distance_matrix.txt\n",
      "Time for MinHash Distance Matrix: 0.0032 seconds\n",
      "MinHash Jaccard Distance Matrix:\n",
      "[[0.         0.26238054 0.98682877 0.98682877]\n",
      " [0.26238054 0.         0.98580122 0.98631526]\n",
      " [0.98682877 0.98580122 0.         0.28473413]\n",
      " [0.98682877 0.98631526 0.28473413 0.        ]]\n",
      "\n",
      "Generating Neighbor-Joining Trees...\n",
      "Time for Full Jaccard Tree: 0.0000 seconds\n",
      "Time for MinHash Jaccard Tree: 0.0000 seconds\n",
      "Newick tree saved to phylogenetic_full_tree.nwk\n",
      "Newick tree saved to phylogenetic_minhash_tree.nwk\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Inputs: Genome k-mers and MinHash sketches\n",
    "genome_files = [\"R6.fa\", \"TIGR4.fa\", \"14412_3#82.contigs_velvet.fa\", \"14412_3#84.contigs_velvet.fa\"]\n",
    "\n",
    "# Load sequences and extract k-mers\n",
    "sequences = {file: load_fasta(file) for file in genome_files}\n",
    "kmers = {file: extract_kmers(sequences[file], k=14) for file in genome_files}\n",
    "\n",
    "# Ensure consistency of keys\n",
    "print(\"Genome files:\", genome_files)\n",
    "print(\"Kmers keys:\", list(kmers.keys()))\n",
    "\n",
    "# Step 1: Compute Full Jaccard Distance Matrix\n",
    "print(\"\\nMethod: Full Jaccard Distance\")\n",
    "print(\"Calculating pairwise distances...\")\n",
    "start_time = time.time()\n",
    "full_distances = {\n",
    "    (genome_files[i], genome_files[j]): full_distance(kmers[genome_files[i]], kmers[genome_files[j]])\n",
    "    for i in range(len(genome_files)) for j in range(i + 1, len(genome_files))\n",
    "}\n",
    "full_distance_matrix = construct_distance_matrix(\n",
    "    genome_files, full_distances, display_graphical=False\n",
    ")\n",
    "full_matrix_time = time.time() - start_time\n",
    "print(f\"Time for Full Jaccard Distance Matrix: {full_matrix_time:.4f} seconds\")\n",
    "print(\"Full Jaccard Distance Matrix:\")\n",
    "print(full_distance_matrix)\n",
    "\n",
    "# Step 2: Generate MinHash Sketches and Compute MinHash Jaccard Distance Matrix\n",
    "print(\"\\nMethod: MinHash Jaccard Distance\")\n",
    "print(\"Generating MinHash sketches...\")\n",
    "start_time = time.time()\n",
    "minhash_sketches = {\n",
    "    file: minhash_sketch(kmers[file], sketch_size=1000) for file in genome_files\n",
    "}\n",
    "sketch_time = time.time() - start_time\n",
    "print(f\"Time for MinHash Sketches: {sketch_time:.4f} seconds\")\n",
    "\n",
    "print(\"Calculating pairwise distances...\")\n",
    "start_time = time.time()\n",
    "minhash_distances = {\n",
    "    (genome_files[i], genome_files[j]): minhash_distance(\n",
    "        minhash_sketches[genome_files[i]], minhash_sketches[genome_files[j]]\n",
    "    )\n",
    "    for i in range(len(genome_files)) for j in range(i + 1, len(genome_files))\n",
    "}\n",
    "minhash_distance_matrix = construct_distance_matrix(\n",
    "    genome_files, minhash_distances, display_graphical=False\n",
    ")\n",
    "minhash_matrix_time = time.time() - start_time\n",
    "print(f\"Time for MinHash Distance Matrix: {minhash_matrix_time:.4f} seconds\")\n",
    "print(\"MinHash Jaccard Distance Matrix:\")\n",
    "print(minhash_distance_matrix)\n",
    "\n",
    "# Step 3: Generate Neighbor-Joining Trees\n",
    "print(\"\\nGenerating Neighbor-Joining Trees...\")\n",
    "start_time = time.time()\n",
    "full_tree = doNeighbourJoining(full_distance_matrix, genome_files)\n",
    "full_tree_time = time.time() - start_time\n",
    "print(f\"Time for Full Jaccard Tree: {full_tree_time:.4f} seconds\")\n",
    "\n",
    "start_time = time.time()\n",
    "minhash_tree = doNeighbourJoining(minhash_distance_matrix, genome_files)\n",
    "minhash_tree_time = time.time() - start_time\n",
    "print(f\"Time for MinHash Jaccard Tree: {minhash_tree_time:.4f} seconds\")\n",
    "\n",
    "# Step 4: Save and Plot Trees\n",
    "save_newick(full_tree, \"phylogenetic_full_tree.nwk\")\n",
    "save_newick(minhash_tree, \"phylogenetic_minhash_tree.nwk\")\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(16, 8))\n",
    "\n",
    "# Full Jaccard Tree\n",
    "ax1 = axes[0]\n",
    "with open(\"phylogenetic_full_tree.nwk\", \"r\") as f:\n",
    "    full_phylo_tree = Phylo.read(f, \"newick\")\n",
    "Phylo.draw(full_phylo_tree, do_show=False, axes=ax1)\n",
    "ax1.set_title(\"Full Jaccard Distance Tree\")\n",
    "\n",
    "# MinHash Jaccard Tree\n",
    "ax2 = axes[1]\n",
    "with open(\"phylogenetic_minhash_tree.nwk\", \"r\") as f:\n",
    "    minhash_phylo_tree = Phylo.read(f, \"newick\")\n",
    "Phylo.draw(minhash_phylo_tree, do_show=False, axes=ax2)\n",
    "ax2.set_title(\"MinHash Jaccard Distance Tree\")\n",
    "\n",
    "# Adjust layout and display\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}