{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e84620fd",
   "metadata": {},
   "source": [
    "# Signal Peptide Detection — Sliding Window vs RNN vs LSTM (PyTorch)\n",
    "\n",
    "This notebook follows the style of **Chapter 9/10** and adds an end-to-end bioinformatics example:\n",
    "\n",
    "1. Obtain a labeled protein dataset from **UniProt** (reviewed Swiss-Prot records with signal-peptide annotations).\n",
    "2. Train a **sliding-window baseline** for residue-level signal peptide detection.\n",
    "3. Train recurrent models (**SimpleRNN** and **LSTM**) for the same residue-labeling task.\n",
    "\n",
    "The task is residue-wise binary labeling on the N-terminus: signal peptide residue (1) vs not (0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ae781caa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If needed:\n",
    "# pip install numpy matplotlib scikit-learn torch\n",
    "\n",
    "from pathlib import Path\n",
    "import re\n",
    "import urllib.parse\n",
    "import urllib.request\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.metrics import (\n",
    "    precision_score, recall_score, f1_score, matthews_corrcoef,\n",
    "    roc_auc_score, average_precision_score, precision_recall_curve\n",
    ")\n",
    "\n",
    "torch.manual_seed(0)\n",
    "np.random.seed(0)\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e14b5fa",
   "metadata": {},
   "source": [
    "## 1) Download and parse a UniProt signal-peptide dataset\n",
    "\n",
    "We query UniProtKB (reviewed proteins), retrieve sequence + signal peptide annotation, and convert annotations to residue-level labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e27d99e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading UniProt TSV...\n",
      "Saved: data/signal_peptides/uniprot_signal.tsv\n",
      "Proteins: 3996 | with signal peptide: 726 | without: 3270\n",
      "Residues: total=1,579,173 | signal=17,355 (1.10%)\n"
     ]
    }
   ],
   "source": [
    "DATA_DIR = Path(\"data/signal_peptides\")\n",
    "DATA_DIR.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "CACHE_TSV = DATA_DIR / \"uniprot_signal.tsv\"\n",
    "\n",
    "UNIPROT_QUERY = \"reviewed:true AND length:[40 TO 800]\"\n",
    "FIELDS = \"accession,sequence,ft_signal\"\n",
    "MAX_RECORDS = 4000\n",
    "\n",
    "def fetch_uniprot_tsv(query, fields, max_records=2000):\n",
    "    base = \"https://rest.uniprot.org/uniprotkb/search\"\n",
    "    params = {\n",
    "        \"query\": query,\n",
    "        \"fields\": fields,\n",
    "        \"format\": \"tsv\",\n",
    "        \"size\": 500,\n",
    "    }\n",
    "\n",
    "    next_url = base + \"?\" + urllib.parse.urlencode(params)\n",
    "    chunks = []\n",
    "    n_rows = 0\n",
    "\n",
    "    while next_url and n_rows < max_records:\n",
    "        req = urllib.request.Request(next_url, headers={\"User-Agent\": \"EkmanTeaching/1.0\"})\n",
    "        with urllib.request.urlopen(req, timeout=60) as resp:\n",
    "            text = resp.read().decode(\"utf-8\", errors=\"ignore\")\n",
    "            lines = text.strip().splitlines()\n",
    "            if not lines:\n",
    "                break\n",
    "\n",
    "            if not chunks:\n",
    "                chunks.extend(lines)\n",
    "                n_rows += max(0, len(lines) - 1)\n",
    "            else:\n",
    "                chunks.extend(lines[1:])\n",
    "                n_rows += len(lines) - 1\n",
    "\n",
    "            link = resp.headers.get(\"Link\", \"\")\n",
    "            m = re.search(r\"<([^>]+)>;\\s*rel=\\\"next\\\"\", link)\n",
    "            next_url = m.group(1) if m else None\n",
    "\n",
    "    return \"\\n\".join(chunks) + \"\\n\"\n",
    "\n",
    "\n",
    "def parse_signal_ranges(signal_field):\n",
    "    if signal_field is None:\n",
    "        return []\n",
    "    txt = str(signal_field).strip()\n",
    "    if txt == \"\" or txt.lower() == \"nan\":\n",
    "        return []\n",
    "\n",
    "    ranges = []\n",
    "    for a, b in re.findall(r\"(\\d+)\\.\\.(\\d+)\", txt):\n",
    "        s = int(a) - 1\n",
    "        e = int(b)\n",
    "        if e > s:\n",
    "            ranges.append((s, e))\n",
    "    return ranges\n",
    "\n",
    "\n",
    "def load_dataset_from_tsv(tsv_text):\n",
    "    lines = [ln for ln in tsv_text.splitlines() if ln.strip()]\n",
    "    header = lines[0].split(\"\\t\")\n",
    "    col = {name: idx for idx, name in enumerate(header)}\n",
    "\n",
    "    accessions = []\n",
    "    sequences = []\n",
    "    labels = []\n",
    "\n",
    "    aa_allowed = set(\"ACDEFGHIKLMNPQRSTVWYXBZUOJ\")\n",
    "\n",
    "    for ln in lines[1:]:\n",
    "        parts = ln.split(\"\\t\")\n",
    "        if len(parts) < len(header):\n",
    "            continue\n",
    "\n",
    "        acc = parts[col.get(\"Entry\", 0)]\n",
    "        seq = parts[col.get(\"Sequence\", 1)].strip().upper()\n",
    "        sig = parts[col.get(\"Signal peptide\", 2)] if \"Signal peptide\" in col else \"\"\n",
    "\n",
    "        if len(seq) < 30 or len(seq) > 1000:\n",
    "            continue\n",
    "        if not set(seq).issubset(aa_allowed):\n",
    "            continue\n",
    "\n",
    "        y = np.zeros(len(seq), dtype=np.int64)\n",
    "        for s, e in parse_signal_ranges(sig):\n",
    "            s = max(0, s)\n",
    "            e = min(len(seq), e)\n",
    "            if e > s:\n",
    "                y[s:e] = 1\n",
    "\n",
    "        accessions.append(acc)\n",
    "        sequences.append(seq)\n",
    "        labels.append(y)\n",
    "\n",
    "    return accessions, sequences, labels\n",
    "\n",
    "\n",
    "if CACHE_TSV.exists():\n",
    "    print(\"Using cached file:\", CACHE_TSV)\n",
    "    tsv_text = CACHE_TSV.read_text(encoding=\"utf-8\", errors=\"ignore\")\n",
    "else:\n",
    "    print(\"Downloading UniProt TSV...\")\n",
    "    tsv_text = fetch_uniprot_tsv(UNIPROT_QUERY, FIELDS, max_records=MAX_RECORDS)\n",
    "    CACHE_TSV.write_text(tsv_text, encoding=\"utf-8\")\n",
    "    print(\"Saved:\", CACHE_TSV)\n",
    "\n",
    "accessions, sequences, labels = load_dataset_from_tsv(tsv_text)\n",
    "\n",
    "num_pos_proteins = int(sum(int(y.sum() > 0) for y in labels))\n",
    "num_neg_proteins = len(labels) - num_pos_proteins\n",
    "num_pos_residues = int(sum(int(y.sum()) for y in labels))\n",
    "num_total_residues = int(sum(len(y) for y in labels))\n",
    "\n",
    "print(f\"Proteins: {len(labels)} | with signal peptide: {num_pos_proteins} | without: {num_neg_proteins}\")\n",
    "print(f\"Residues: total={num_total_residues:,} | signal={num_pos_residues:,} ({100*num_pos_residues/max(1,num_total_residues):.2f}%)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d7ff1a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quick EDA\n",
    "lengths = np.array([len(s) for s in sequences], dtype=np.int64)\n",
    "sig_lengths = np.array([int(y.sum()) for y in labels], dtype=np.int64)\n",
    "\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.hist(lengths, bins=40)\n",
    "plt.xlabel(\"protein length\")\n",
    "plt.ylabel(\"count\")\n",
    "plt.title(\"Sequence length distribution\")\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.hist(sig_lengths[sig_lengths > 0], bins=30)\n",
    "plt.xlabel(\"signal peptide length\")\n",
    "plt.ylabel(\"count\")\n",
    "plt.title(\"Annotated signal peptide lengths\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44d54a7d",
   "metadata": {},
   "source": [
    "## 2) Train/test split and residue window extraction\n",
    "\n",
    "To focus on signal peptides, we train on the **N-terminus** only (first `NTERM_LEN` residues)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "19ba48dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train proteins: 3196 | Test proteins: 800\n"
     ]
    }
   ],
   "source": [
    "NTERM_LEN = 70\n",
    "TRAIN_FRAC = 0.8\n",
    "\n",
    "idx = np.arange(len(sequences))\n",
    "rng = np.random.default_rng(0)\n",
    "rng.shuffle(idx)\n",
    "split = int(TRAIN_FRAC * len(idx))\n",
    "idx_train = idx[:split]\n",
    "idx_test = idx[split:]\n",
    "\n",
    "seq_train = [sequences[i] for i in idx_train]\n",
    "lab_train = [labels[i] for i in idx_train]\n",
    "seq_test = [sequences[i] for i in idx_test]\n",
    "lab_test = [labels[i] for i in idx_test]\n",
    "\n",
    "print(f\"Train proteins: {len(seq_train)} | Test proteins: {len(seq_test)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8db549a",
   "metadata": {},
   "source": [
    "## 3) Baseline model: sliding window (logistic classifier)\n",
    "\n",
    "Each residue is represented by a local amino-acid window around that position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cff46ad1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliding-window residue samples train/test: (223357, 15) (55936, 15)\n",
      "Positive rate train/test: 0.06251427087577287 0.06064073226544622\n",
      "Sliding-window metrics:\n",
      "  precision: 0.2571\n",
      "     recall: 0.8894\n",
      "         f1: 0.3989\n",
      "        mcc: 0.4241\n",
      "      auroc: 0.9354\n",
      "       aupr: 0.5480\n"
     ]
    }
   ],
   "source": [
    "AA = \"ACDEFGHIKLMNPQRSTVWY\"\n",
    "aa_to_idx = {a: i for i, a in enumerate(AA)}\n",
    "UNK_IDX = len(AA)\n",
    "VOCAB_SIZE = len(AA) + 1\n",
    "\n",
    "WINDOW = 15\n",
    "R = WINDOW // 2\n",
    "\n",
    "def aa_index(ch):\n",
    "    return aa_to_idx.get(ch, UNK_IDX)\n",
    "\n",
    "def make_residue_examples(seq_list, lab_list, nterm_len=70, window=15):\n",
    "    r = window // 2\n",
    "    X_idx = []\n",
    "    y = []\n",
    "\n",
    "    for seq, yseq in zip(seq_list, lab_list):\n",
    "        L = min(len(seq), nterm_len)\n",
    "        for pos in range(L):\n",
    "            w = []\n",
    "            for j in range(pos - r, pos + r + 1):\n",
    "                if 0 <= j < L:\n",
    "                    w.append(aa_index(seq[j]))\n",
    "                else:\n",
    "                    w.append(UNK_IDX)\n",
    "            X_idx.append(w)\n",
    "            y.append(int(yseq[pos]))\n",
    "\n",
    "    return np.array(X_idx, dtype=np.int64), np.array(y, dtype=np.int64)\n",
    "\n",
    "\n",
    "def one_hot_flat(X_idx, vocab_size):\n",
    "    n, w = X_idx.shape\n",
    "    out = np.zeros((n, w * vocab_size), dtype=np.float32)\n",
    "    for i in range(n):\n",
    "        for p in range(w):\n",
    "            out[i, p * vocab_size + X_idx[i, p]] = 1.0\n",
    "    return out\n",
    "\n",
    "\n",
    "Xtr_idx, ytr = make_residue_examples(seq_train, lab_train, nterm_len=NTERM_LEN, window=WINDOW)\n",
    "Xte_idx, yte = make_residue_examples(seq_test, lab_test, nterm_len=NTERM_LEN, window=WINDOW)\n",
    "\n",
    "print(\"Sliding-window residue samples train/test:\", Xtr_idx.shape, Xte_idx.shape)\n",
    "print(\"Positive rate train/test:\", ytr.mean(), yte.mean())\n",
    "\n",
    "Xtr = one_hot_flat(Xtr_idx, VOCAB_SIZE)\n",
    "Xte = one_hot_flat(Xte_idx, VOCAB_SIZE)\n",
    "\n",
    "clf = SGDClassifier(loss=\"log_loss\", alpha=1e-4, class_weight=\"balanced\", random_state=0, max_iter=1000)\n",
    "clf.fit(Xtr, ytr)\n",
    "\n",
    "proba_sw = clf.predict_proba(Xte)[:, 1]\n",
    "pred_sw = (proba_sw >= 0.5).astype(np.int64)\n",
    "\n",
    "metrics_sw = {\n",
    "    \"precision\": precision_score(yte, pred_sw, zero_division=0),\n",
    "    \"recall\": recall_score(yte, pred_sw, zero_division=0),\n",
    "    \"f1\": f1_score(yte, pred_sw, zero_division=0),\n",
    "    \"mcc\": matthews_corrcoef(yte, pred_sw),\n",
    "    \"auroc\": roc_auc_score(yte, proba_sw) if len(np.unique(yte)) > 1 else np.nan,\n",
    "    \"aupr\": average_precision_score(yte, proba_sw),\n",
    "}\n",
    "\n",
    "print(\"Sliding-window metrics:\")\n",
    "for k, v in metrics_sw.items():\n",
    "    print(f\"  {k:>9s}: {v:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88df303f",
   "metadata": {},
   "source": [
    "## 4) Recurrent residue labeling: SimpleRNN and LSTM\n",
    "\n",
    "We encode each protein N-terminus as a sequence, then predict a binary label per position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0601617c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training SimpleRNN tagger...\n",
      "epoch 01 | loss 0.3447 | f1 0.0000 | aupr 0.1358\n",
      "epoch 02 | loss 0.2062 | f1 0.3707 | aupr 0.3949\n",
      "epoch 03 | loss 0.1706 | f1 0.4157 | aupr 0.4643\n",
      "epoch 04 | loss 0.1575 | f1 0.4696 | aupr 0.4751\n",
      "epoch 05 | loss 0.1466 | f1 0.4049 | aupr 0.5096\n",
      "epoch 06 | loss 0.1407 | f1 0.3484 | aupr 0.5252\n",
      "\n",
      "Training LSTM tagger...\n",
      "epoch 01 | loss 0.4337 | f1 0.0000 | aupr 0.1505\n",
      "epoch 02 | loss 0.2084 | f1 0.0000 | aupr 0.3072\n",
      "epoch 03 | loss 0.1543 | f1 0.1137 | aupr 0.4701\n",
      "epoch 04 | loss 0.1410 | f1 0.2614 | aupr 0.5203\n",
      "epoch 05 | loss 0.1337 | f1 0.3446 | aupr 0.5379\n",
      "epoch 06 | loss 0.1277 | f1 0.4191 | aupr 0.5449\n"
     ]
    }
   ],
   "source": [
    "def encode_protein_batch(seq_list, lab_list, nterm_len=70):\n",
    "    X = np.full((len(seq_list), nterm_len), UNK_IDX, dtype=np.int64)\n",
    "    Y = np.zeros((len(seq_list), nterm_len), dtype=np.float32)\n",
    "    M = np.zeros((len(seq_list), nterm_len), dtype=np.float32)\n",
    "\n",
    "    for i, (seq, yseq) in enumerate(zip(seq_list, lab_list)):\n",
    "        L = min(len(seq), nterm_len)\n",
    "        for j in range(L):\n",
    "            X[i, j] = aa_index(seq[j])\n",
    "            Y[i, j] = float(yseq[j])\n",
    "            M[i, j] = 1.0\n",
    "\n",
    "    return X, Y, M\n",
    "\n",
    "\n",
    "X_train_seq, y_train_seq, m_train_seq = encode_protein_batch(seq_train, lab_train, nterm_len=NTERM_LEN)\n",
    "X_test_seq, y_test_seq, m_test_seq = encode_protein_batch(seq_test, lab_test, nterm_len=NTERM_LEN)\n",
    "\n",
    "train_ds = TensorDataset(\n",
    "    torch.from_numpy(X_train_seq),\n",
    "    torch.from_numpy(y_train_seq),\n",
    "    torch.from_numpy(m_train_seq),\n",
    ")\n",
    "test_ds = TensorDataset(\n",
    "    torch.from_numpy(X_test_seq),\n",
    "    torch.from_numpy(y_test_seq),\n",
    "    torch.from_numpy(m_test_seq),\n",
    ")\n",
    "\n",
    "train_loader = DataLoader(train_ds, batch_size=64, shuffle=True)\n",
    "test_loader = DataLoader(test_ds, batch_size=128, shuffle=False)\n",
    "\n",
    "class SeqTagger(nn.Module):\n",
    "    def __init__(self, vocab_size, emb_dim=24, hid_dim=48, kind=\"rnn\"):\n",
    "        super().__init__()\n",
    "        self.emb = nn.Embedding(vocab_size, emb_dim)\n",
    "        if kind == \"lstm\":\n",
    "            self.rnn = nn.LSTM(emb_dim, hid_dim, batch_first=True)\n",
    "        else:\n",
    "            self.rnn = nn.RNN(emb_dim, hid_dim, batch_first=True, nonlinearity=\"tanh\")\n",
    "        self.out = nn.Linear(hid_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        z = self.emb(x)\n",
    "        h, _ = self.rnn(z)\n",
    "        logits = self.out(h).squeeze(-1)\n",
    "        return logits\n",
    "\n",
    "\n",
    "def train_sequence_model(model, train_loader, test_loader, epochs=6, lr=1e-3):\n",
    "    model = model.to(device)\n",
    "    opt = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "\n",
    "    def run_eval(loader):\n",
    "        model.eval()\n",
    "        all_p, all_y = [], []\n",
    "        with torch.no_grad():\n",
    "            for xb, yb, mb in loader:\n",
    "                xb = xb.to(device)\n",
    "                yb = yb.to(device)\n",
    "                mb = mb.to(device)\n",
    "                logits = model(xb)\n",
    "                probs = torch.sigmoid(logits)\n",
    "\n",
    "                keep = mb > 0\n",
    "                all_p.append(probs[keep].detach().cpu().numpy())\n",
    "                all_y.append(yb[keep].detach().cpu().numpy())\n",
    "\n",
    "        p = np.concatenate(all_p).astype(np.float32)\n",
    "        y = np.concatenate(all_y).astype(np.int64)\n",
    "        pred = (p >= 0.5).astype(np.int64)\n",
    "\n",
    "        out = {\n",
    "            \"precision\": precision_score(y, pred, zero_division=0),\n",
    "            \"recall\": recall_score(y, pred, zero_division=0),\n",
    "            \"f1\": f1_score(y, pred, zero_division=0),\n",
    "            \"mcc\": matthews_corrcoef(y, pred),\n",
    "            \"auroc\": roc_auc_score(y, p) if len(np.unique(y)) > 1 else np.nan,\n",
    "            \"aupr\": average_precision_score(y, p),\n",
    "            \"y\": y,\n",
    "            \"proba\": p,\n",
    "        }\n",
    "        return out\n",
    "\n",
    "    for ep in range(1, epochs + 1):\n",
    "        model.train()\n",
    "        losses = []\n",
    "        for xb, yb, mb in train_loader:\n",
    "            xb = xb.to(device)\n",
    "            yb = yb.to(device)\n",
    "            mb = mb.to(device)\n",
    "\n",
    "            opt.zero_grad(set_to_none=True)\n",
    "            logits = model(xb)\n",
    "\n",
    "            loss_all = nn.functional.binary_cross_entropy_with_logits(logits, yb, reduction=\"none\")\n",
    "            loss = (loss_all * mb).sum() / mb.sum().clamp_min(1.0)\n",
    "            loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
    "            opt.step()\n",
    "            losses.append(float(loss.item()))\n",
    "\n",
    "        val = run_eval(test_loader)\n",
    "        print(f\"epoch {ep:02d} | loss {np.mean(losses):.4f} | f1 {val['f1']:.4f} | aupr {val['aupr']:.4f}\")\n",
    "\n",
    "    return run_eval(test_loader)\n",
    "\n",
    "\n",
    "print(\"Training SimpleRNN tagger...\")\n",
    "res_rnn = train_sequence_model(SeqTagger(VOCAB_SIZE, kind=\"rnn\"), train_loader, test_loader, epochs=6, lr=1e-3)\n",
    "\n",
    "print(\"\\nTraining LSTM tagger...\")\n",
    "res_lstm = train_sequence_model(SeqTagger(VOCAB_SIZE, kind=\"lstm\"), train_loader, test_loader, epochs=6, lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "84dd7931",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Final test metrics\n",
      "\n",
      "[SlidingWindow]\n",
      "  precision: 0.2571\n",
      "     recall: 0.8894\n",
      "         f1: 0.3989\n",
      "        mcc: 0.4241\n",
      "       aupr: 0.5480\n",
      "      auroc: 0.9354\n",
      "\n",
      "[SimpleRNN]\n",
      "  precision: 0.7490\n",
      "     recall: 0.2270\n",
      "         f1: 0.3484\n",
      "        mcc: 0.3947\n",
      "       aupr: 0.5252\n",
      "      auroc: 0.9276\n",
      "\n",
      "[LSTM]\n",
      "  precision: 0.6421\n",
      "     recall: 0.3110\n",
      "         f1: 0.4191\n",
      "        mcc: 0.4238\n",
      "       aupr: 0.5449\n",
      "      auroc: 0.9476\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1020x460 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Aggregate and visualize results\n",
    "results = {\n",
    "    \"SlidingWindow\": {**metrics_sw, \"y\": yte, \"proba\": proba_sw},\n",
    "    \"SimpleRNN\": res_rnn,\n",
    "    \"LSTM\": res_lstm,\n",
    "}\n",
    "\n",
    "metric_names = [\"precision\", \"recall\", \"f1\", \"mcc\", \"aupr\", \"auroc\"]\n",
    "model_names = list(results.keys())\n",
    "\n",
    "print(\"\\nFinal test metrics\")\n",
    "for name in model_names:\n",
    "    print(f\"\\n[{name}]\")\n",
    "    for m in metric_names:\n",
    "        print(f\"  {m:>9s}: {results[name][m]:.4f}\")\n",
    "\n",
    "plt.figure(figsize=(10.2, 4.6))\n",
    "x = np.arange(len(metric_names))\n",
    "w = 0.25\n",
    "for i, name in enumerate(model_names):\n",
    "    vals = [results[name][m] for m in metric_names]\n",
    "    plt.bar(x + (i-1)*w, vals, width=w, label=name)\n",
    "\n",
    "plt.xticks(x, metric_names, rotation=20)\n",
    "plt.ylim(0, 1.0)\n",
    "plt.ylabel(\"score\")\n",
    "plt.title(\"Signal peptide residue detection: model comparison\")\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(6.4, 5.0))\n",
    "for name in model_names:\n",
    "    y_true = results[name][\"y\"]\n",
    "    p = results[name][\"proba\"]\n",
    "    pr, rc, _ = precision_recall_curve(y_true, p)\n",
    "    ap = average_precision_score(y_true, p)\n",
    "    plt.plot(rc, pr, linewidth=2, label=f\"{name} (AUPR={ap:.3f})\")\n",
    "\n",
    "baseline = np.mean(results[model_names[0]][\"y\"])\n",
    "plt.axhline(baseline, linestyle=\"--\", color=\"gray\", linewidth=1.2, label=f\"baseline={baseline:.3f}\")\n",
    "plt.xlabel(\"Recall\")\n",
    "plt.ylabel(\"Precision\")\n",
    "plt.title(\"Precision-Recall curves (residue-level)\")\n",
    "plt.xlim(0, 1)\n",
    "plt.ylim(0, 1)\n",
    "plt.legend(loc=\"lower left\")\n",
    "plt.grid(alpha=0.25)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e37f859",
   "metadata": {},
   "source": [
    "## 5) Notes and extensions\n",
    "\n",
    "- This notebook uses only sequence and UniProt signal-peptide annotation (`ft_signal`).\n",
    "- The current objective is residue-wise binary tagging in the N-terminus.\n",
    "- You can extend this to cleavage-site prediction (single boundary position) or multi-class region tagging (n-/h-/c-region).\n",
    "- If the downloaded class balance is too skewed, increase `MAX_RECORDS` or perform per-protein balancing."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ekman-teaching",
   "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}