{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fcd93fc6",
   "metadata": {},
   "source": [
    "# Protein Contact Prediction with CNNs (PyTorch)\n",
    "\n",
    "This notebook demonstrates **protein contact prediction** using CNN architectures similar to those in Chapter 7.\n",
    "\n",
    "## Background\n",
    "Proteins fold into 3D structures, and knowing which amino acids are in contact (distance < 8Å) helps predict these structures. Tools like trRosetta use deep learning to predict contacts from sequence information.\n",
    "\n",
    "## What we'll build\n",
    "1. **Input representation**: Encode protein sequences (20 amino acids + features) into 2D grids\n",
    "2. **Contact labels**: Create synthetic distance maps (1 = contact, 0 = no contact)\n",
    "3. **CNN architecture**: Adapt Conf4/Conf5 from Chapter 7 for contact prediction\n",
    "4. **Training & evaluation**: Train on synthetic data, visualize predictions\n",
    "\n",
    "**Note**: This is an educational example with toy data. Real contact predictors use MSA features, evolutionary information, and much larger datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "86b1aabb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: cuda\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader, TensorDataset\n",
    "from sklearn.metrics import precision_recall_curve, auc\n",
    "\n",
    "torch.manual_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Device: {device}\")\n",
    "\n",
    "# ESM-2 will be imported later when needed\n",
    "try:\n",
    "    import esm\n",
    "    ESM_AVAILABLE = True\n",
    "except ImportError:\n",
    "    ESM_AVAILABLE = False\n",
    "    print(\"⚠️  ESM-2 not installed. Install with: pip install fair-esm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e209ab",
   "metadata": {},
   "source": [
    "## 1) Protein Sequence Representation\n",
    "\n",
    "We'll encode amino acids and create synthetic protein \"features.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "37bdac22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amino acids: ACDEFGHIKLMNPQRSTVWY\n",
      "Example: A=0, W=18\n",
      "\n",
      "Sequence length: 20\n",
      "One-hot shape: (20, 20)\n",
      "PSSM shape: (20, 20)\n",
      "Contact map shape: (20, 20)\n",
      "Num contacts: 64 / 400\n"
     ]
    }
   ],
   "source": [
    "# Standard amino acids (20)\n",
    "AMINO_ACIDS = \"ACDEFGHIKLMNPQRSTVWY\"\n",
    "AA_TO_IDX = {aa: i for i, aa in enumerate(AMINO_ACIDS)}\n",
    "IDX_TO_AA = {i: aa for aa, i in AA_TO_IDX.items()}\n",
    "\n",
    "print(f\"Amino acids: {AMINO_ACIDS}\")\n",
    "print(f\"Example: A={AA_TO_IDX['A']}, W={AA_TO_IDX['W']}\")\n",
    "\n",
    "def sequence_to_onehot(seq):\n",
    "    \"\"\"Convert amino acid sequence to one-hot encoding (L, 20)\"\"\"\n",
    "    seq = seq.upper()\n",
    "    indices = [AA_TO_IDX.get(aa, 0) for aa in seq]  # Unknown → A\n",
    "    onehot = np.eye(20)[indices]\n",
    "    return onehot.astype(np.float32)\n",
    "\n",
    "def create_pssm_feature(seq, strength=0.5):\n",
    "    \"\"\"Create a synthetic PSSM-like feature (position-specific scoring matrix)\"\"\"\n",
    "    L = len(seq)\n",
    "    # Simulate evolutionary conservation: higher score for similar residues\n",
    "    pssm = np.random.randn(L, 20) * 0.2\n",
    "    for i, aa in enumerate(seq.upper()):\n",
    "        if aa in AA_TO_IDX:\n",
    "            idx = AA_TO_IDX[aa]\n",
    "            pssm[i, idx] += strength  # Higher score for native AA\n",
    "    return pssm.astype(np.float32)\n",
    "\n",
    "def create_distance_map(L, seq):\n",
    "    \"\"\"Create synthetic distance map (contact if dist < 8Å)\"\"\"\n",
    "    # Random 3D coordinates\n",
    "    xyz = np.random.randn(L, 3) * 5\n",
    "    \n",
    "    # Compute pairwise distances\n",
    "    dist = np.linalg.norm(xyz[:, None, :] - xyz[None, :, :], axis=2)\n",
    "    \n",
    "    # Contacts: distance < 8Å, but not adjacent (i and i+1, i+2, etc.)\n",
    "    contacts = dist < 8.0\n",
    "    for i in range(L):\n",
    "        for j in range(max(0, i-2), min(L, i+3)):\n",
    "            contacts[i, j] = False  # Remove sequence-local contacts\n",
    "    \n",
    "    return contacts.astype(np.float32), dist\n",
    "\n",
    "# Example\n",
    "seq_example = \"ACDEFGHIKLMNPQRSTVWY\"[:20]  # 20 AA sequence\n",
    "onehot = sequence_to_onehot(seq_example)\n",
    "pssm = create_pssm_feature(seq_example)\n",
    "contacts, dist = create_distance_map(len(seq_example), seq_example)\n",
    "\n",
    "print(f\"\\nSequence length: {len(seq_example)}\")\n",
    "print(f\"One-hot shape: {onehot.shape}\")\n",
    "print(f\"PSSM shape: {pssm.shape}\")\n",
    "print(f\"Contact map shape: {contacts.shape}\")\n",
    "print(f\"Num contacts: {contacts.sum():.0f} / {contacts.size}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d95fe8c",
   "metadata": {},
   "source": [
    "## ESM-2: Protein Language Model Features\n",
    "\n",
    "ESM-2 (Evolutionary Scale Modeling) is a transformer-based protein language model from Meta AI. It learns representations directly from protein sequences without alignment information, capturing:\n",
    "- Structural properties\n",
    "- Functional information  \n",
    "- Evolutionary patterns\n",
    "\n",
    "**Key advantage**: ESM-2 embeddings are learned from 2.7 billion proteins and are more informative than simple one-hot + PSSM features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "133ea07b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing ESM-2 embedding extraction...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (1, 20, 320)\n",
      "ESM-2 embedding shape: (1, 20, 320)\n"
     ]
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def _load_esm2_model(model_name=None):\n",
    "    \"\"\"Load an ESM-2 model and alphabet, with fallbacks.\"\"\"\n",
    "    if not ESM_AVAILABLE:\n",
    "        print(\"ESM-2 not available. Skipping ESM features.\")\n",
    "        return None, None, None\n",
    "\n",
    "    if model_name is None:\n",
    "        model_candidates = [\n",
    "            \"esm2_t6_8M_UR50D\",\n",
    "            \"esm2_t12_35M_UR50D\",\n",
    "            \"esm2_t30_150M_UR50D\",\n",
    "            \"esm2_t6_8M\",\n",
    "        ]\n",
    "        model_name = model_candidates[0]\n",
    "\n",
    "    try:\n",
    "        print(f\"Loading ESM-2 model ({model_name})...\")\n",
    "        try:\n",
    "            model, alphabet = esm.pretrained.load_model_and_alphabet_hub(model_name)\n",
    "        except Exception:\n",
    "            model, alphabet = esm.pretrained.load_model_and_alphabet_local(model_name)\n",
    "    except Exception as e:\n",
    "        print(f\"⚠️  Could not load {model_name}: {e}\")\n",
    "        print(\"Available ESM models: Run esm.pretrained.model_hub to see options\")\n",
    "        return None, None, None\n",
    "\n",
    "    model = model.to(device)\n",
    "    model.eval()\n",
    "    return model, alphabet, model_name\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def get_esm2_embeddings(sequences, model_name=None):\n",
    "    \"\"\"Extract ESM-2 embeddings for protein sequences.\n",
    "\n",
    "    Args:\n",
    "        sequences: List of amino acid sequences (strings)\n",
    "        model_name: ESM-2 model variant (auto-detected if None)\n",
    "    Returns:\n",
    "        embeddings: (num_seqs, seq_len, embed_dim) tensor of embeddings\n",
    "    \"\"\"\n",
    "    model, alphabet, model_name = _load_esm2_model(model_name)\n",
    "    if model is None:\n",
    "        return None\n",
    "\n",
    "    batch_converter = alphabet.get_batch_converter()\n",
    "    _, _, batch_tokens = batch_converter(\n",
    "        [(f\"seq_{i}\", seq) for i, seq in enumerate(sequences)]\n",
    "    )\n",
    "    batch_tokens = batch_tokens.to(device)\n",
    "\n",
    "    try:\n",
    "        results = model(batch_tokens, repr_layers=[6])\n",
    "        embeddings = results[\"representations\"][6]\n",
    "    except KeyError:\n",
    "        num_layers = model.num_layers\n",
    "        results = model(batch_tokens, repr_layers=[num_layers - 1])\n",
    "        embeddings = results[\"representations\"][num_layers - 1]\n",
    "\n",
    "    embeddings = embeddings[:, 1:-1, :].cpu().numpy()\n",
    "    print(f\"✓ Extracted embeddings with shape: {embeddings.shape}\")\n",
    "    return embeddings\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def get_esm2_attention_maps(sequences, model_name=None):\n",
    "    \"\"\"Extract mean attention maps from ESM-2 heads (per sequence).\n",
    "\n",
    "    Returns: (num_seqs, seq_len, seq_len) attention maps.\n",
    "    \"\"\"\n",
    "    model, alphabet, model_name = _load_esm2_model(model_name)\n",
    "    if model is None:\n",
    "        return None\n",
    "\n",
    "    batch_converter = alphabet.get_batch_converter()\n",
    "    _, _, batch_tokens = batch_converter(\n",
    "        [(f\"seq_{i}\", seq) for i, seq in enumerate(sequences)]\n",
    "    )\n",
    "    batch_tokens = batch_tokens.to(device)\n",
    "\n",
    "    try:\n",
    "        results = model(batch_tokens, repr_layers=[model.num_layers], need_head_weights=True)\n",
    "    except TypeError:\n",
    "        results = model(batch_tokens, repr_layers=[model.num_layers], need_head_weights=True)\n",
    "\n",
    "    attn = results.get(\"attentions\", None)\n",
    "    if attn is None or attn.ndim != 5:\n",
    "        print(\"⚠️  Attention weights not available from this model.\")\n",
    "        return None\n",
    "\n",
    "    if attn.shape[0] == model.num_layers:\n",
    "        attn_last = attn[-1]\n",
    "    elif attn.shape[1] == model.num_layers:\n",
    "        attn_last = attn[:, -1]\n",
    "    else:\n",
    "        attn_last = attn[-1]\n",
    "\n",
    "    if attn_last.ndim == 4:\n",
    "        attn_mean = attn_last.mean(dim=1)\n",
    "    elif attn_last.ndim == 3:\n",
    "        attn_mean = attn_last\n",
    "    else:\n",
    "        print(\"⚠️  Unexpected attention tensor shape.\")\n",
    "        return None\n",
    "\n",
    "    attn_mean = attn_mean[:, 1:-1, 1:-1].cpu().numpy().astype(np.float32)\n",
    "    print(f\"✓ Extracted attention maps with shape: {attn_mean.shape}\")\n",
    "    return attn_mean\n",
    "\n",
    "\n",
    "# Test on example sequence (if ESM available)\n",
    "if ESM_AVAILABLE:\n",
    "    print(\"Testing ESM-2 embedding extraction...\")\n",
    "    try:\n",
    "        esm_emb = get_esm2_embeddings([seq_example])\n",
    "        if esm_emb is not None:\n",
    "            print(f\"ESM-2 embedding shape: {esm_emb.shape}\")\n",
    "        else:\n",
    "            print(\"⚠️  Could not extract ESM-2 embeddings\")\n",
    "    except Exception as e:\n",
    "        print(f\"⚠️  ESM-2 test failed: {e}\")\n",
    "        print(\"You may need to check ESM installation or model availability\")\n",
    "else:\n",
    "    print(\"⚠️  Skipping ESM-2 test (package not installed)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "107290fe",
   "metadata": {},
   "source": [
    "## 2) Create Training Dataset\n",
    "\n",
    "Generate synthetic protein sequences with contact labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "6088c7d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train: 80 proteins\n",
      "Test: 20 proteins\n",
      "Batch input shape: torch.Size([4, 40, 64, 64]) (batch, channels, height, width)\n",
      "Batch target shape: torch.Size([4, 1, 64, 64]) (batch, 1, height, width)\n",
      "Contact density: 0.220\n"
     ]
    }
   ],
   "source": [
    "class ProteinDataset(Dataset):\n",
    "    def __init__(self, num_proteins=100, seq_length=64, use_esm2=False, use_esm2_attn=False):\n",
    "        self.num_proteins = num_proteins\n",
    "        self.seq_length = seq_length\n",
    "        self.use_esm2 = use_esm2 and ESM_AVAILABLE\n",
    "        self.use_esm2_attn = use_esm2_attn and ESM_AVAILABLE\n",
    "        self.proteins = []\n",
    "\n",
    "        sequences = []\n",
    "        for _ in range(num_proteins):\n",
    "            seq = ''.join(np.random.choice(list(AMINO_ACIDS), seq_length))\n",
    "            sequences.append(seq)\n",
    "\n",
    "        esm2_embeddings = None\n",
    "        if self.use_esm2:\n",
    "            print(f\"Extracting ESM-2 embeddings for {num_proteins} proteins...\")\n",
    "            esm2_embeddings = get_esm2_embeddings(sequences)\n",
    "            if esm2_embeddings is not None:\n",
    "                print(f\"ESM-2 embeddings shape: {esm2_embeddings.shape}\")\n",
    "\n",
    "        esm2_attn_maps = None\n",
    "        if self.use_esm2_attn:\n",
    "            print(f\"Extracting ESM-2 attention maps for {num_proteins} proteins...\")\n",
    "            esm2_attn_maps = get_esm2_attention_maps(sequences)\n",
    "            if esm2_attn_maps is not None:\n",
    "                print(f\"ESM-2 attention map shape: {esm2_attn_maps.shape}\")\n",
    "\n",
    "        for seq_idx, seq in enumerate(sequences):\n",
    "            onehot = sequence_to_onehot(seq)\n",
    "            pssm = create_pssm_feature(seq)\n",
    "            features = np.concatenate([onehot, pssm], axis=1)  # (L, 40)\n",
    "\n",
    "            if self.use_esm2 and esm2_embeddings is not None:\n",
    "                esm_feat = esm2_embeddings[seq_idx]  # (seq_len, 320)\n",
    "                features = np.concatenate([features, esm_feat[:, :64]], axis=1)  # (L, 104)\n",
    "\n",
    "            feature_2d = (\n",
    "                features[:, None, :] + features[None, :, :]\n",
    "            ) / 2  # (L, L, C)\n",
    "\n",
    "            if self.use_esm2_attn and esm2_attn_maps is not None:\n",
    "                attn_map = esm2_attn_maps[seq_idx]  # (L, L)\n",
    "                feature_2d = np.concatenate([feature_2d, attn_map[..., None]], axis=2)\n",
    "\n",
    "            contacts, _ = create_distance_map(seq_length, seq)\n",
    "\n",
    "            self.proteins.append({\n",
    "                'seq': seq,\n",
    "                'features': feature_2d,\n",
    "                'contacts': contacts,\n",
    "            })\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.num_proteins\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        p = self.proteins[idx]\n",
    "        x = torch.from_numpy(p['features']).permute(2, 0, 1)\n",
    "        y = torch.from_numpy(p['contacts']).unsqueeze(0)\n",
    "        return x, y\n",
    "\n",
    "# Create train/test split\n",
    "train_ds = ProteinDataset(num_proteins=80, seq_length=64)\n",
    "test_ds = ProteinDataset(num_proteins=20, seq_length=64)\n",
    "\n",
    "train_loader = DataLoader(train_ds, batch_size=4, shuffle=True)\n",
    "test_loader = DataLoader(test_ds, batch_size=4, shuffle=False)\n",
    "\n",
    "print(f\"Train: {len(train_ds)} proteins\")\n",
    "print(f\"Test: {len(test_ds)} proteins\")\n",
    "\n",
    "# Check shapes\n",
    "x, y = next(iter(train_loader))\n",
    "print(f\"Batch input shape: {x.shape} (batch, channels, height, width)\")\n",
    "print(f\"Batch target shape: {y.shape} (batch, 1, height, width)\")\n",
    "print(f\"Contact density: {y.mean():.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8268c7f2",
   "metadata": {},
   "source": [
    "## 3) Contact Prediction CNN (adapted from Conf4/Conf5)\n",
    "\n",
    "We'll use a U-Net-like architecture for dense per-position predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "de43442e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default model (U-Net) parameters: 1.89M\n",
      "Conf5-style model parameters: 1.58M\n",
      "Input shape: torch.Size([4, 40, 64, 64])\n",
      "Output shape: torch.Size([4, 1, 64, 64])\n"
     ]
    }
   ],
   "source": [
    "class ConvBlock(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, dropout_p=0.0):\n",
    "        super().__init__()\n",
    "        layers = [\n",
    "            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.ReLU(inplace=True),\n",
    "        ]\n",
    "        if dropout_p > 0:\n",
    "            layers.append(nn.Dropout2d(dropout_p))\n",
    "        layers.extend([\n",
    "            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.ReLU(inplace=True),\n",
    "        ])\n",
    "        self.block = nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.block(x)\n",
    "\n",
    "\n",
    "class ContactPredictorConf5(nn.Module):\n",
    "    \"\"\"Conf5-style contact predictor (no spatial down/up sampling).\"\"\"\n",
    "    def __init__(self, in_channels=40, dropout_p=0.2):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels, 64, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout2d(dropout_p),\n",
    "            nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "        self.conv2 = nn.Sequential(\n",
    "            nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout2d(dropout_p),\n",
    "            nn.Conv2d(128, 128, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "        self.conv3 = nn.Sequential(\n",
    "            nn.Conv2d(128, 256, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(256),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout2d(dropout_p),\n",
    "            nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(256),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "        self.up1 = nn.Conv2d(256, 128, kernel_size=1)\n",
    "        self.conv4 = nn.Sequential(\n",
    "            nn.Conv2d(128 + 128, 128, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "        self.up2 = nn.Conv2d(128, 64, kernel_size=1)\n",
    "        self.conv5 = nn.Sequential(\n",
    "            nn.Conv2d(64 + 64, 64, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "        self.output = nn.Conv2d(64, 1, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        e1 = self.conv1(x)\n",
    "        e2 = self.conv2(e1)\n",
    "        e3 = self.conv3(e2)\n",
    "\n",
    "        d1 = self.up1(e3)\n",
    "        d1 = torch.cat([d1, e2], dim=1)\n",
    "        d1 = self.conv4(d1)\n",
    "\n",
    "        d2 = self.up2(d1)\n",
    "        d2 = torch.cat([d2, e1], dim=1)\n",
    "        d2 = self.conv5(d2)\n",
    "\n",
    "        logits = self.output(d2)\n",
    "        return logits\n",
    "\n",
    "\n",
    "class ContactPredictorUNet(nn.Module):\n",
    "    \"\"\"True U-Net architecture for dense protein contact prediction.\"\"\"\n",
    "    def __init__(self, in_channels=40, dropout_p=0.2):\n",
    "        super().__init__()\n",
    "\n",
    "        self.enc1 = ConvBlock(in_channels, 64, dropout_p=dropout_p)\n",
    "        self.pool1 = nn.MaxPool2d(kernel_size=2)\n",
    "        self.enc2 = ConvBlock(64, 128, dropout_p=dropout_p)\n",
    "        self.pool2 = nn.MaxPool2d(kernel_size=2)\n",
    "\n",
    "        self.bottleneck = ConvBlock(128, 256, dropout_p=dropout_p)\n",
    "\n",
    "        self.up2 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)\n",
    "        self.dec2 = ConvBlock(256, 128, dropout_p=dropout_p)\n",
    "\n",
    "        self.up1 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)\n",
    "        self.dec1 = ConvBlock(128, 64, dropout_p=dropout_p)\n",
    "\n",
    "        self.output = nn.Conv2d(64, 1, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        e1 = self.enc1(x)\n",
    "        e2 = self.enc2(self.pool1(e1))\n",
    "        b = self.bottleneck(self.pool2(e2))\n",
    "\n",
    "        u2 = self.up2(b)\n",
    "        if u2.shape[-2:] != e2.shape[-2:]:\n",
    "            u2 = F.interpolate(u2, size=e2.shape[-2:], mode='bilinear', align_corners=False)\n",
    "        d2 = self.dec2(torch.cat([u2, e2], dim=1))\n",
    "\n",
    "        u1 = self.up1(d2)\n",
    "        if u1.shape[-2:] != e1.shape[-2:]:\n",
    "            u1 = F.interpolate(u1, size=e1.shape[-2:], mode='bilinear', align_corners=False)\n",
    "        d1 = self.dec1(torch.cat([u1, e1], dim=1))\n",
    "\n",
    "        logits = self.output(d1)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# Keep old notebook API name, defaulting to U-Net\n",
    "ContactPredictorCNN = ContactPredictorUNet\n",
    "\n",
    "# Default model used in the rest of notebook\n",
    "model = ContactPredictorUNet(in_channels=40, dropout_p=0.2).to(device)\n",
    "print(f\"Default model (U-Net) parameters: {sum(p.numel() for p in model.parameters())/1e6:.2f}M\")\n",
    "\n",
    "# Show parameter counts for both architectures\n",
    "model_conf5_probe = ContactPredictorConf5(in_channels=40, dropout_p=0.2).to(device)\n",
    "print(f\"Conf5-style model parameters: {sum(p.numel() for p in model_conf5_probe.parameters())/1e6:.2f}M\")\n",
    "del model_conf5_probe\n",
    "\n",
    "# Test forward pass\n",
    "with torch.no_grad():\n",
    "    x_test, y_test = next(iter(train_loader))\n",
    "    x_test = x_test.to(device)\n",
    "    logits = model(x_test)\n",
    "    print(f\"Input shape: {x_test.shape}\")\n",
    "    print(f\"Output shape: {logits.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d1dbc35",
   "metadata": {},
   "source": [
    "## 4) Training Loop\n",
    "\n",
    "Train the contact predictor with binary cross-entropy loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "91fef8dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 01/30 | train loss 0.6825 | test loss 0.6156\n",
      "Epoch 05/30 | train loss 0.5589 | test loss 0.5586\n",
      "Epoch 10/30 | train loss 0.5349 | test loss 0.5599\n",
      "Epoch 15/30 | train loss 0.5168 | test loss 0.5553\n",
      "Epoch 20/30 | train loss 0.5018 | test loss 0.5682\n",
      "Epoch 25/30 | train loss 0.4866 | test loss 0.5799\n",
      "Epoch 30/30 | train loss 0.4731 | test loss 0.5936\n",
      "Training complete!\n"
     ]
    }
   ],
   "source": [
    "criterion = nn.BCEWithLogitsLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-5)\n",
    "\n",
    "def train_epoch(model, loader, optimizer, criterion, device):\n",
    "    model.train()\n",
    "    total_loss = 0.0\n",
    "    for x, y in loader:\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        optimizer.zero_grad(set_to_none=True)\n",
    "        \n",
    "        logits = model(x)\n",
    "        loss = criterion(logits, y)\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        total_loss += float(loss.item())\n",
    "    return total_loss / len(loader)\n",
    "\n",
    "@torch.no_grad()\n",
    "def eval_epoch(model, loader, criterion, device):\n",
    "    model.eval()\n",
    "    total_loss = 0.0\n",
    "    for x, y in loader:\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        logits = model(x)\n",
    "        loss = criterion(logits, y)\n",
    "        total_loss += float(loss.item())\n",
    "    return total_loss / len(loader)\n",
    "\n",
    "# Train\n",
    "num_epochs = 30\n",
    "train_losses = []\n",
    "test_losses = []\n",
    "\n",
    "for ep in range(1, num_epochs + 1):\n",
    "    tr_loss = train_epoch(model, train_loader, optimizer, criterion, device)\n",
    "    te_loss = eval_epoch(model, test_loader, criterion, device)\n",
    "    \n",
    "    train_losses.append(tr_loss)\n",
    "    test_losses.append(te_loss)\n",
    "    \n",
    "    if ep % 5 == 0 or ep == 1:\n",
    "        print(f\"Epoch {ep:02d}/{num_epochs} | train loss {tr_loss:.4f} | test loss {te_loss:.4f}\")\n",
    "\n",
    "print(\"Training complete!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a646420b",
   "metadata": {},
   "source": [
    "## 5) Learning Curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5fdbc75c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArEAAAGZCAYAAACezWnrAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZqFJREFUeJzt3Qd4k1X7BvC7e9JNW0bZs+wlSxkiUxFwgAtRXLgRcX+KqH/nJ+KCTxw4QEBRhspUtqDsvSnQ0kHpbulu87+eExK6k7aZzf27rtc2yZvk7ZtU7p485zlOGo1GAyIiIiIiO+Js7QMgIiIiIqouhlgiIiIisjsMsURERERkdxhiiYiIiMjuMMQSERERkd1hiCUiIiIiu8MQS0RERER2hyGWiIiIiOwOQywRERER2R2GWCKqtoMHD+L+++9H8+bN4enpCV9fX3Tv3h3vv/8+UlJSzHZG4+Li8Prrr2P//v1me46aPM+mTZvg5OSk31xcXBAWFobbb78dx44dgyUMGjRIbTrnzp1Tx/Ltt99W63GOHj2qfna5vyWUPG9VbXKOa0N+JnmcmtC9vrU9BiIyLVcTPx4R1XFffvklHnvsMbRt2xbPPfccIiMjUVBQgN27d+N///sfduzYgWXLlpktXM6cORPNmjVD165dzfIctXmet99+G4MHD0Z+fr46H2+88Qb++usvHDp0CI0aNYIlNWjQQL0WLVu2rHaIlZ9dArH8/OYmx1jSm2++iY0bN2LDhg2lrpf3WW08+OCDGDFiRI3uK3+gyXHW9hiIyLQYYonIaPIP+aOPPoqhQ4di+fLl8PDw0N8m1z377LNYs2aNw57R1q1bo0+fPur7AQMGICAgAA888IAaDX3llVcqvE92dja8vb1Nfizy2uiOxRZU9nOWPcb69evD2dnZ4LFX97w1btxYbTXh5+dnU+eSiLRYTkBE1RpplI9V582bVyrA6ri7u+Pmm2/WXy4uLlYlBu3atVP7h4aG4t5778WFCxdK3U9G/Tp27Ihdu3bhuuuuU+GkRYsWePfdd9VjCPkot1evXup7KWXQfcwsHxMLGfm844471Oihl5eX+nrnnXfi/Pnz5Y4zNjYWDz/8MCIiItQxN2zYELfddhsuXrxo8HmqQxd8dMeg+0h779696vkCAwP1I6UajQZz5sxRI79y/HKb7BMVFVXqMWU/OadNmzZVpRwySrh69epyz11ZOcHx48fVeZFyB3lNmjRpol6TvLw8ta+UQAgZUdb97CUf45tvvkGXLl3UcwcFBWHcuHHlSibuu+8+VWIiI9DDhg1DvXr1MGTIENSU7v2xZcsW9OvXT70/Jk+erG5bsmSJeg4ZeZbz1r59e7z44ou4fPmywXICeY/cdNNN6g8vOY9yf3mvys9oqJxA9zOePn0ao0aNUt/L+0n+kJNzWZK83+W1lPMgf9jcfffd6r1ek3IPIrqKIZaIjFJUVKQ+4u3Ro4f6x9oYMmr7wgsvqFHalStXqo+KJTBIEElKSiq1b0JCgvrH/Z577lH7jhw5Ei+99BIWLFigbpeQMX/+fPX9f/7zHzUqLJt8TKwLbVLiMHv2bKxduxbvvfce4uPjVSAt+VwSYOU6KXmYNm2aCoByH39/f6Smphp8nuqQgKMbXSzplltuQatWrfDzzz+rEgzxyCOPYOrUqbjhhhvUKLcE2iNHjqhzJeFaRz7q151T2U/O8UMPPYQTJ04YPJ4DBw6on/2ff/5RpQ7ys7/zzjsqdEkJxI033qj+UBGff/65/meX64XsKyPLHTp0wK+//oqPP/5Y1Uf37dsXp06dKvVc8njyB83111+PFStWqOOuDXkt5b1x1113YdWqVaqkRcjzSoj8+uuv1XtLzuFPP/2E0aNHG/W4ck4keD7zzDPqODt37qx+RgnMhkgZjfyMEtDlvhKsP/roI/Xe05EwLX8QSImEXC/HJn9ATJgwoRZng4gUDRGRERISEjTyv4w77rjDqPN17Ngxtf9jjz1W6vp///1XXf/yyy/rrxs4cKC6Tm4rKTIyUjN8+HD95V27dqn95s+fb/D5CwsLNVlZWRofHx/Nxx9/rL9+8uTJGjc3N83Ro0crvW91nkds3LhR7b9kyRJNQUGBJjs7W7NlyxZNq1atNC4uLpoDBw6o/WbMmKH2e+2110rdf8eOHer6Dz/8sNT1MTExGi8vL83zzz+vLqempmo8PT0148aNK7Xf33//re4v51Hn7Nmz5X6G66+/XhMQEKBJTEys9Gf5+eef1f3kZypJnluOZdSoUaWuj46O1nh4eGjuuusu/XWTJk1Sj/HNN99oqkvuK69ZSbr3x19//VXlfYuLi9X537x5s9pfd95LnvuSmjZtqs7n+fPn9dfl5ORogoKCNI888ki517fkOdH9jD/99FOpx5Tz07ZtW/3lzz//XO23evXqUvvJ41fnPUZE5XEklojMQkaedB+7lnTNNdeoj3xlwlNJ4eHh6raSZFSsonKAimRlZakRShnhdHV1VZt8xCsjYSU/7pbRRxkZk2MwNRldc3NzUx93S02sjF4vXbpU/Rwl3XrrraUu//777+qjZRlpLCws1G9yTuSje93H2DIqmpubq0asS5LRWikvMFRDunnzZowfP77cyLAx5LlzcnLKvZ4yKi+jrWVfz4p+ztqQ8gp5nrKk3EJGZ+VcSVcIOf8DBw5UtxnTGULKN6SkQkfKJNq0aWPU+05es7IjvmXfs3LOpYyg7KQyKekgotrhxC4iMkpISIgKZ2fPnjVq/+TkZPVVahXLkhrUsiEhODi43H5SsynByRgSZCRIvfrqq+ojc5mMIyFDPmou+RiXLl2q8QQfQ+TjYglaEqbkfFVWdlH2nEi5gNS6ysfMFZH64JLnVAJbWRVdV5KUSkiorunPbuj1XL9+fanr5L0ir4GpVPS88oeL1FBL8HzrrbdU+JTnjYmJUSUbxrx3avO+k+eS5y57X/lDo+R5q+h1rey1JiLjMcQSkVEkmEntn4xkykQVQ2FIFw6klrHsvtLCSkKeqaSnp6vRzBkzZqhJPTpS61m2b62MQpadWGYqEjZ79uxpcL+yE4zkXMh1W7durXDCnO463TmV+uGy5LqqWmLJJCx5DWv6s5d8Pcuq6PWsaU/WylT0eFKjLc8tI9W60VeRlpYGWyHnbefOneWur+g1JKLqYTkBERlNJlrJiKFMJJKJOxVNdPntt9/U97qPfnUTs3RkVrZ8zFuT2eq6MFd2lEwCjhxX2QD41VdfqdHHkmTCmJQ6VDURqrLnMReZIS/HL5POJASX3Tp16qTvdiAjfwsXLix1/+3btxv8+Ftm3kvQk8lkZSfVGfOzy+QteYyyr6eEYgmTtek+UNtgW/Z1/+KLL2Ar5JxnZmaW6yCxePFiqx0TUV3BkVgiMpoEmblz56qZ4dKlQGbGy0x1Ca/79u1TrbekFZLUCUqnAGlj9emnn6q+nxIepYOAfNwvH7PLbPDqknZUEqQkxElNq9S8ykfZskkN6gcffKBGBGVEUmoRZca6tDQqSTcrX/Z/+eWXVUCUkTuZ2S7dCqTFUlXPYw79+/dX50paekmrMDk2Hx8fNeq5bds2dYxyrqUudPr06eqjc+mWIO2w5KNzaR9lqJxAzJo1C9deey169+6tRqylflhKGaQbhAQ/qd2U10/IaymXJTTLymwyoiivnZwzacklNZ3yUbl0HZB9ZBTc0qQWWM7JlClT1PNLPay8ZtJxwFZMmjRJdSyQemd53eScy/tPOmgI+d0goprhbw8RVYuMwkrQkhArNaDSo3Ps2LFYtGiRqkuV8KMjgVd6vUpLJBltlIb/sr+MHFZUi2hMDaL08JTwJI8jta+65/vxxx/VhK3nn39e1UPKMUqdprTOKklWzpKPd+V45Nhkws2TTz6pShLkI3dDz2MuEiI/++wz1dpJ+t1KW6vXXntNTUwrOeFNQri0ulq3bp1q7yR/JEibLvmjwRCZJCY/u7x2MqouP7tMhpORTOmXKySwSssxCYLSn1V+dt3outxHRrflNnnNn3jiCfVHjLyestCDpcl76I8//lCvl4REaXElf3BI71hbIX+MyEi1nEt5b8pkt+joaNVCTZT9I4uIjOckLQqqsT8RERHVkvTjlT7EEmjNNdGQqK5jOQEREZEZyQi7kFIVKb2RkdlPPvlEjR4zwBLVHEMsERGRGUm5g9TFSk24dMyQvrRSxiEjsURUcywnICIiIiK7w4ldRERERGR3GGKJiIiIyO6wJrYCxcXFahUY6ZFo6lVniIiIiKhi0jRLFgiRvtyG+igzxFZAAmxla54TERERkXnJQi6GuncwxFZARmB1J9DPz888rw4RERERlZKRkaEGEnVZrCoMsRXQlRBIgGWIJSIiIrIsY8o5ObGLiIiIiOwOQywRERER2R2GWCIiIiKyO6yJJSIiIrtTVFSEgoICax8GVZObmxtcXFxgCgyxREREZFd9RBMSEpCWlmbtQ6EaCggIQHh4eK178TPEEhERkd3QBdjQ0FB4e3tzUSI7+wMkOzsbiYmJ6nKDBg1q9XgMsURERGQ3JQS6ABscHGztw6Ea8PLyUl8lyMrrWJvSAoZYKysq1mDn2RQkZuYitJ4nrmkeBBdnLnVLRERUlq4GVkZgyX7pXj95PRli7dSaw/GY+dtRxKfn6q9r4O+JGaMjMaJj7YbYiYiI6qra1lJS3Xj92GLLigH20QV7SwVYkZCeq66X24mIiIioYgyxViohkBFYTQW36a6T22U/IiIiIiqPIdYKpAa27AhsSRJd5XbZj4iIiExPBop2nEnGiv2x6qu9DRw1a9YMs2fPtvpjWBMndlmBTOIy5X5ERERk23NSBg0ahK5du5osNO7atQs+Pj5wZByJtQLpQmDK/YiIiMj+56RIH9XCwkKj9q1fv77Dd2lgiLUCaaMlf/FVNjdPrpfbZT8iIiIy0EA/v9CoLTO3ADNWHqlyTsrrK4+q/Yx5PHluY9x3333YvHkzPv74YzUzX7Zz585h06ZN6vu1a9eiZ8+e8PDwwNatW3HmzBmMGTMGYWFh8PX1Ra9evfDnn39WWQrg5OSEr776CuPGjVPhtnXr1li5cmW13jrR0dHqeeU5/fz8MH78eFy8eFF/+4EDBzB48GDUq1dP3d6jRw/s3r1b3Xb+/HmMHj0agYGBaoS4Q4cOWLVqFcyJ5QRWIH1g5SML+YtPAmvJXwFdsJXb2S+WiIioajkFRYh8ba1JTpP8e5yQkYtOr68zav+jbwyHt7vhKCXh9eTJk+jYsSPeeOMN/UiqBFnx/PPP47///S9atGihlmS9cOECRo0ahbfeeguenp747rvvVEA8ceIEmjRpUunzzJw5E++//z4++OADfPrpp7j77rtVuAwKMjwoJoF87NixKoBK4JYR4cceewwTJkxQYVvI43Xr1g1z585V/V33798PNzc3ddvjjz+O/Px8bNmyRT3G0aNHVRg2J4ZYK5Gam7n3dC9XkxPOPrFERER1ir+/P9zd3dUIaXh4eLnbJdgOHTpUf1lWI+vSpYv+soTZZcuWqZHVJ554osoR3zvvvFN9//bbb6sgu3PnTowYMcLgMcpI78GDB3H27FlERESo63744Qc1oir1tzIaLCO1zz33HNq1a6dul9FeHbnt1ltvRadOndRlCeTmxhBr5SA7NDIcM1YexoJ/otGnRRAWPtiHI7BERERG8nJzUSOixpCuP/fN32Vwv2/v72VUSZ88tylIKUFJly9fVqOqv//+O+Li4tSoaE5OjgqKVencubP+exkNlY/9ZXlXYxw7dkyFV12AFZGRkWpkWG6TEDtt2jQ8+OCDKtzecMMNuP3229GyZUu171NPPYVHH30U69atU7dJoC15PObAmlgrk5KBa1vVV9/nFBQzwBIREVWD1ILKR/rGbNe1rm/UnBTZz5jHM9XKU2W7DMho5y+//IL/+7//UzWy8rG9jHDKx/VVcbvy0b7+53FyQnFxsVHHIOUEFf08Ja9//fXXceTIEdx4443YsGGDCrkyQiwk3EZFRWHixIk4dOiQCuYyEmxODLE2ICLIS32NTc229qEQERHV+TkpomxcM/ecFCknKCoqMmpfCa5SGiCTtCS8SgmCrn7WXCIjI9VIb0xMjP46qWtNT09H+/bt9de1adMGzzzzjBpxveWWWzB//nz9bTKKO2XKFPz666949tln8eWXX5r1mBlibUDjQG/1NSkrX812JCIiIvPOSZE5KCXJZbneXH1ipZvAv//+q8JoUlJSlSOkrVq1UkFQRmClI8Bdd91l9IhqTUkJgHz8L5O39u7dq2pp7733XgwcOFCNqko5g9TjyiQvmSz2999/q1pZXcCdOnWq6rIgNbVyfxmpLRl+zYE1sTbA38sN9TxdkZlbiNjUHLQOq2ftQyIiIqrzc1KkRlYWFpK+7FIDa86uQNOnT8ekSZPUiKcEQgl7lfnoo48wefJk9OvXDyEhIXjhhReQkZEBc3JycsLy5cvx5JNPYsCAAXB2dlYTwnQlAdKNIDk5WQVbabslxyUjsVK7K2SUWToUSGcFab8l95Wfw6zHrDG2yZkDkTeKzCSUIXR5ISxh1MdbcTQ+A/Pv64XB7UIt8pxERET2JDc3V4W/5s2bq9ZTVPdex+pkMJYT2IjGgdq62BjWxRIREREZxBBrY3WxF1JzrH0oRERERDaPIdbGOhRc4EgsERERkUEMsTY2EhuTwpFYIiIiIkMYYm2sJpYjsURERESGMcTaWIhNzS5AVh57xRIRERFVhSHWRtTzdEOAt3a5OI7GEhEREVWNIdYWSwpYF0tERERUJYZYGxKhb7OVbe1DISIiIrJpXHbWJhc8YIcCIiIis0iLAbKTK7/dOxgIiKhTJ3/QoEHo2rUrZs+ejbqEIdYmFzzgSCwREZFZAuxnPYDCvMr3cfUAnthj8iBrjiB53333IS0tDcuXL4cjYjmBTS54wJFYIiIik5MR2KoCrJDbqxqpJZvBEGuTCx5wJJaIiMgoGg2Qf9m4rdDIQSLZz5jHk+c2csR08+bN+Pjjj+Hk5KS2c+fOqduOHj2KUaNGwdfXF2FhYZg4cSKSkpL09126dCk6deoELy8vBAcH44YbbsDly5fx+uuv47vvvsOKFSv0j7lp0yajjic1NRX33nsvAgMD4e3tjZEjR+LUqVP628+fP4/Ro0er2318fNChQwesWrVKf9+7774b9evXV8fUunVrzJ8/H9bAcgIb0ihAOxKbkVuI9JwC+HtpW24RERFRJQqygbcbmvb0fDPCuP1ejgPcfQzuJuH15MmT6NixI9544w11nYTA+Ph4DBw4EA899BBmzZqFnJwcvPDCCxg/fjw2bNigbr/zzjvx/vvvY9y4ccjMzMTWrVuh0Wgwffp0HDt2DBkZGfoQGRQUZHSoltC6cuVK+Pn5qeeUIC2B2s3NDY8//jjy8/OxZcsWFWLlegnZ4tVXX1WXV69ejZCQEJw+fVodtzUwxNoQHw9XBPu4I/lyPmJTcxhiiYiI6gB/f3+4u7urUc/w8HD99XPnzkX37t3x9ttv66/75ptvEBERoUJvVlYWCgsLccstt6Bp06bqdhmV1fHy8kJeXl6pxzREF17//vtv9OvXT123cOFC9ZxSW3v77bcjOjoat956q/65WrRoob+/3NatWzf07NlTXW7WrBmshSHWBjsUSIiNSc1GZEM/ax8OERGRbXPz1o6IGiPhoHGjrJPXAOGdjXvuWtizZw82btyoH+Us6cyZMxg2bBiGDBmiwuTw4cPV5dtuu019zF9TMnrr6uqK3r1766+TMoW2bduq28RTTz2FRx99FOvWrVPlCxJoO3fWng+5Xi7v3btXHc/YsWP1YdjSWBNrsx0KOLmLiIjIICcn7Uf6xmyu2rI9g2Q/Yx5PnrsWiouLVe3p/v37S20yWjpgwAC4uLhg/fr16qP7yMhIfPrppypsnj17tsbPKaUIlV0vdbXiwQcfRFRUlKrPPXTokBp1lecWUj8rNbNTp05FXFycCtlS2mANDLE2prG+QwEndxEREdUVUk5QVFRU6jopJThy5Ij6SL5Vq1alNqlFFRIs+/fvj5kzZ2Lfvn3qcZYtW1bpYxoiYVhKFP7991/9dcnJyap8oX379vrrpLxgypQp+PXXX/Hss8/iyy+/1N8m9bxSV7tgwQLVMmzevHmwBoZYm+1QwJFYIiIik5KFDKQPbFXkdtnPxCSoSnCUrgTSfUBGYWUCVUpKipq8tXPnTjX6KR/hT548WYVT2V/qZXfv3q1qUSVQXrp0SR82mzVrhoMHD+LEiRPqMQsKCgweh3QTGDNmjJpMtm3bNhw4cAD33HMPGjVqpK4XMsq6du1aNeIrZQMyyUz3nK+99prqiCATuiSA//7776XCryWxJtZGV+3iSCwREZGJyQIGspCBFVbsko/cJ02apEZCZTa/BEQJoTLBSroDSM2rTNKSCVwjRoyAs7Oz6hwgHQJktFO6EMhtH374ofpIX0gQlbZa8nG/TAKT+lpZVMEQ6Wbw9NNP46abblJdCKR0QVpoSWcCIQFaAvaFCxfUMcjxfPTRR/rR35deekmFcZlYdt1112Hx4sWwBidNZcURDkzeKDKTMD09Xb14lnQ6MQs3zNqMeh6uOPj6MH19ChERkaPLzc1V4a958+bw9PS09uGQGV7H6mQwlhPY6EhsZp62VywRERERlccQa2M83VwQ4qut12GHAiIiIqKKMcTaoAh2KCAiIiKqEkOsDWKHAiIiIqKqMcTaIHYoICIiqpy0pyL7ZarXjy22bFAEV+0iIiIqR9o7SespWSlKGu7LZXbxsR/SEEtaekmvW3kd5fWrDYZYGx6JjeGqXURERHoSfKQtU3x8vAqyZJ+8vb3RpEkT9XrWBkOsDbpaTpBTai1jIiIiRyejdxKAZOnU6i65Stbn4uICV1dXk2Qbhlgb1OhKiM3OL0JqdgGCfGo33E5ERFSXSACS1aV0K0yRY+LELhvk4eqCMD9tr9iYlGxrHw4RERGRzWGItfE2W1zwgIiIiMgGQ+ycOXP0a+f26NEDW7durXL/vLw8vPLKK2jatCk8PDzQsmVLfPPNN/rbv/32W/UxQ9lN1um1JxGc3EVERERkmzWxS5YswdSpU1WQ7d+/P7744guMHDkSR48eVUXbFRk/fjwuXryIr7/+Gq1atUJiYqIq7i7Jz88PJ06cKHWdhGT7HIllOQERERGRTYXYWbNm4YEHHsCDDz6oLs+ePRtr167F3Llz8c4775Tbf82aNdi8eTOioqIQFBSkrmvWrFm5/WTkNTw83OjjkNFd2XQyMjJgSx0KiIiIiMhGygmk2e2ePXswbNiwUtfL5e3bt1d4n5UrV6Jnz554//330ahRI7Rp0wbTp09HTk7poJeVlaXKDRo3boybbroJ+/btq/JYJDD7+/vrt4iICFhbRJB2JJYTu4iIiIhsKMQmJSWp/m5hYWGlrpfLCQkJFd5HRmC3bduGw4cPY9myZWrkdunSpXj88cf1+7Rr107VxUrgXbRokSojkFKFU6dOVXosL730EtLT0/VbTEwMbK1XLBERERHZUJ/Yss1uq2ruL2vtym0LFy5UI6a6koTbbrsNn3/+Oby8vNCnTx+16UiA7d69Oz799FN88sknFT6uTBCTzZY08PeCnIa8wmIkZeWjfj3bOj4iIiIihxyJDQkJUas2lB11lYlaZUdndRo0aKDKCHQBVrRv314F3wsXLlR4H1nSrFevXlWOxNoid1dnNPDTTkbj8rNERERENhJiZdk4aam1fv36UtfL5X79+lV4HxlVlbWSpeZV5+TJkyqoSv1rRSTg7t+/XwVge8NesUREREQ22Cd22rRp+Oqrr1Sf12PHjuGZZ55BdHQ0pkyZoq9Vvffee/X733XXXQgODsb999+v2nBt2bIFzz33HCZPnqxKCcTMmTNVhwOpn5XwKt0P5KvuMe3J1bpYttkiIiIispma2AkTJiA5ORlvvPEG4uPj0bFjR6xatUp1FhBynYRaHV9fXzVS++STT6ouBRJopW/sW2+9pd8nLS0NDz/8sCpTkLKDbt26qbB7zTXXwN401ncoYJstIiIiopKcNJz6Xo70iZUALJ0KZOEEa/lpdwyeX3oQ17UOwQ8P9LbacRARERHZWgaz+rKzZLicIJYLHhARERGVwhBrwyL0S8/moLiYvWKJiIiIdBhibVgDf0+4ODshv6gYl7KuLotLRERE5OgYYm2Yq4uzCrKCHQqIiIiIrmKItZO6WHYoICIiIrqKIdZuFjxgr1giIiIiHYZYO5rcRURERERaDLH2Uk7AkVgiIiIiPYZYu1l6liOxRERERDoMsTYu4srSs3FpOShir1giIiIihSHWxoX5ecLV2QkFRRpczMi19uEQERER2QSGWBsnix00DGBJAREREVFJDLF2ICJIF2LZZouIiIhIMMTagcYB2rpYLnhAREREpMUQa1cdCjgSS0RERCQYYu2oQwHbbBERERFpMcTaAS54QERERFQaQ6wdaHxl6dn49FwUFhVb+3CIiIiIrI4h1g6E1vOAu4uzWuwggb1iiYiIiBhi7YGzsxMaXZncxQ4FRERERAyxdoMdCoiIiIiuYjmBndXFskMBEREREUOs3WCHAiIiIqKrOBJrd+UEOdY+FCIiIiKrY4i1swUPYhliiYiIiBhi7W0kNj49BwXsFUtEREQOjiOxdqK+rwc8XJ1RrAHi03KtfThEREREVsUQayecnJzYZouIiIjoCoZYO2yzFZOabe1DISIiIrIqhlg7wg4FRERERFoMsXbYoYBttoiIiMjRMcTa44IHKSwnICIiIsfGEGtHuPQsERERkRZDrB2JuDISezEzF3mFRdY+HCIiIiKrYYi1I0E+7vByc4FGA8SxVywRERE5MIZYO8JesURERERarle+kqWlxQDZyZXf7h0MBERU2KHgVGIWOxQQERGRQ2OItVaA/awHUJhX+T6uHsATe8oFWXYoICIiImI5gXXICGxVAVbI7RWM1HLBAyIiIiKGWLsTcWXp2QtcepaIiIgcGCd22Wmv2JjUHGsfChEREZHVMMTaGV05waXMPOQWsFcsEREROSaGWDsT4O0GXw/tfLzYNI7GEhERkWNiiLXjXrExKdnWPhwiIiIiq2CItUPsUEBERESOjiHWGmQhA+kDWxW5XfarYnLXBU7uIiIiIgfFxQ6sQRYwkIUMSvaB/fl+IDUKGPom0HxApSt2CX05AdtsERERkYNiiLUWCaglQ2rLwcDuKCAzAWjYtcq7ciSWiIiIHB3LCWxF037ar9HbDe4aEaQdiY3lSCwRERE5KIZYW9Gkj/Zr/EEgL8uokdikrHxk5xda4uiIiIiIbApDrK3wbwz4RwCaIiB2d9W7ermhnueVXrGc3EVEREQOiCHWFkdjo/8xuGsEOxQQERGRA2OItSVN+mq/njdcF8sOBUREROTIGGJtMcRe2A0UFVS5KzsUEBERkSNjiLUl9dsBnv5AwWUg4ZBRHQousEMBEREROSCGWFvi7AxEGFcXqxuJjUnJscSREREREdkUhlhb07SvUf1idTWxHIklIiIiR8QQa6t1sTISq9EYDLGp2QXIymOvWCIiInIsDLG2pmE3wMUDuHwJSImqdLd6nm4I8HZT33M0loiIiBwNQ6ytcfUAGnXXfh+9w7iSAtbFEhERkYOxeoidM2cOmjdvDk9PT/To0QNbt26tcv+8vDy88soraNq0KTw8PNCyZUt88803pfb55ZdfEBkZqW6Xr8uWLYN99ovdYeSCB9mWOCoiIiIim2HVELtkyRJMnTpVhdJ9+/bhuuuuw8iRIxEdHV3pfcaPH4+//voLX3/9NU6cOIFFixahXbt2+tt37NiBCRMmYOLEiThw4ID6Kvf5999/YX91scaNxMZw6VkiIiJyME4aTRWzh8ysd+/e6N69O+bOnau/rn379hg7dizeeeedcvuvWbMGd9xxB6KiohAUFFThY0qAzcjIwOrVq/XXjRgxAoGBgSrwVja6K5uO3D8iIgLp6enw8/ODxeWkAe81A6ABpp8CfEMr3O277ecwY+URDO8Qhi8m9rT4YRIRERGZkmQwf39/ozKY1UZi8/PzsWfPHgwbNqzU9XJ5+/aK20utXLkSPXv2xPvvv49GjRqhTZs2mD59OnJyckqNxJZ9zOHDh1f6mEICs5ww3SYB1qq8AoCwDgb7xV5d8IC9YomIiMixWC3EJiUloaioCGFhYaWul8sJCQkV3kdGYLdt24bDhw+rOtfZs2dj6dKlePzxx/X7yH2r85jipZdeUolft8XExMDqmvQxWFJwdcED1sQSERGRY3G19gE4OTmVuizVDWWv0ykuLla3LVy4UI2YilmzZuG2227D559/Di8vr2o/ppAJYLLZXF3srq+qDLGNArQ/b0ZuIdJzCuDvpW25RURERFTXVXskVupSZTRUR8Jj165dcddddyE1NdXoxwkJCYGLi0u5EdLExMRyI6k6DRo0UGUEugCrq6GVkHrhwgV1OTw8vFqPabN0I7HxB4G8rAp38fFwRbCPu/o+liUFRERE5ECqHWKfe+45VXQrDh06hGeffRajRo1SH/VPmzbN6Mdxd3dXLbXWr19f6nq53K9fvwrv079/f8TFxSEr62qoO3nyJJydndG4cWN1uW/fvuUec926dZU+ps3ybwz4NwE0RUDsbiM6FLCkgIiIiEwgLQaI21/5JrfbYznB2bNnVe9VXT/Wm266CW+//Tb27t2rwmx1SOiVFlgyWUvC57x581R7rSlTpuhrVWNjY/H999+ryzLa++abb+L+++/HzJkzVV2thOrJkyfrSwmefvppDBgwAO+99x7GjBmDFStW4M8//yw1emxXo7GHorX9YlsMqrQu9sCFdE7uIiIiotqTgPpZD6DwatemChdmemIPEBBhXyOxMoKana0d9ZNwqOsEIC2vdCO0xpJ2WDI564033lAlCVu2bMGqVavUQgYiPj6+VM9YX19fNcqalpamgu/dd9+N0aNH45NPPtHvIyOuixcvxvz589G5c2d8++23qh+ttPOyO8ZM7tJ3KOBILBEREdVSdnLVAVbI7bKfvY3EXnvttWoEVT7a37lzpwqIuo/1dR/pV8djjz2mtopIAC1LFjYoWy5Qlkz0ks3u6RY9uLAbKCoAXNyq6FDANltERETkOKo9EvvZZ5/B1dVVtbaSRQpkopWQxQVkUQEyofrtAM8AoOAykHCoyppYjsQSERGRI6n2SGyTJk3w+++/l7v+o48+MtUxkY6zs7ak4OQabUlBo+7lzk3ElZFY6U5gqJUYERERUaWKCg0ueW/XI7EygUu6EujIxClZJvbll19Wq3CRZetidSOxmXnaXrFERERE1ZJ4HFj3KvBRJLDmRdTZkdhHHnkEL774Ijp16qTaat1xxx0YN24cfv75ZzXhSyZqkRnqYmX5WY1GVnIodbOnmwtCfD2QlJWnOhQEeGv7xhIREZGDdRXIrmKylXdw6W4C2SnA4V+A/T8CcXuvXu/pD+Smo06GWJnAJZ0EhARXaWf1448/4u+//1aBliHWxBp2A1w8gMuXgJQoILhluV0igryuhNhsdGx0dSEIIiIicgBpRrbFemwnkHwK2L8QOP4HUHTlE3RnV6DNCKDrXYBPKPD1DaiTIVbqLmX5V12LLekTKyIiIlTfVjL1K+QBNOoBRG8Hzm+vMMRKh4J90WnsUEBEROSIso1si/Xl9UBOidHasI5A17uBzuMBn5CrgViyh6FALCO79hZipT/rW2+9hRtuuAGbN29WHQp0iyDY3dKu9lQXKyFWSgq6Tyx3cwQ7FBAREdX9EoDayknWPman8dpR1wady+8jzycLGVjyuCwVYqVcQBYZWL58OV555RW0atVKXS8tt+xuaVe7q4utbHKXtkOB1MQSERGRA62MVZALpJ4z7jmHvgn0ngK4Gpg/I89nAyHV5CFWVsEq2Z1A54MPPoCLi4upjotKirgGgBOQcgbISgR8QyvsUBDDVbuIiIjq3spYXgFAylnt3BjZUuX7K5cz4qTY07jnbD7AcIC1I9UOsTp79uzBsWPHVF/S9u3bo3v38j1MyUTkzRvWAbh4WDsaGzmm1M0RQVdHYtkrloiIqA75fgyQm1b1Pm4+2oWRHEy1Q2xiYiImTJig6mEDAgJUaEpPT8fgwYOxePFi1K9f3zxH6uikLlaF2H/KhdiGAZ7qa3Z+EVKzCxDkU3f+yiIiIrK72lNT0gVYOcagFtotsPnV74OaA+kxwLxBcDTVDrFPPvkkMjMzceTIETUCK44ePYpJkybhqaeewqJFi8xxnCR1sbu+qrAu1sPVBWF+HriYkYeYlGyGWCIiIlPXnlrLLV8CbYZr+7dWJv0CHFG1V+xas2aN6kigC7AiMjISn3/+OVavXm3q46Oyk7viDwJ5WZUuP8vJXURERDWsPbUUWWhg64fG7RvSpuoAqxullSBeFRtpi2XVkVjpEevm5lbuerlO1z+WzMC/EeDfBEiPBi7sAloOLje5a/f5VLXgAREREdkgyUkHFgHrXzVtaA6wn7ZYVg2x119/PZ5++mlVNtCwYUN1XWxsLJ555hkMGTLEHMdIJetiD0Vr62LLhVjtSCw7FBAREV0hy7XLDH5bcPEI8MezV8sCA5oBaUa2xjJGgH20xbJqiP3ss88wZswYNGvWTK3SJd0JoqOj0alTJ/zwww/mOUrSatoXOPRThXWxsvSsYDkBERE59GSsokLtv5MnVmmXVk07b9zzJZ8GGnaFyeVlApveBf6ZC2iKtJ0EBr0ItB8NzOltFytj1ZkQK8F17969WL9+PY4fP666E0hNrKzgRRaqi5VygqICwOVqWQcXPCAiIoedjCVB8cwG4Pgq4NRaICf16n7ObkBxgeHn/OUBYOc8oNdDQOTNhmtMjRkFPrIMWPsykBmvva79zcCIdwD/xtrLDlgCYBN9YocOHao2HekZe+ONNyIqykaG7euikLaAZ4C23UbCQaBRj3ILHkhNLHvFEhGRQ0zG2vMNEH8IOLsZKMq/eptXENBmBNBuFOATAnwzwvBzOrkAMf9qtzUhQPd7gZ6TaxYik04Dq54FojZpL0tLrFH/BVqXGfBzwBIAmwixZeXn5+P8eSOH7KlmnJ21dbEn12jrYkuE2Ab+XnB2AnILipGUlY/69Wr5FyQREZGt2zrr6vcSFNvdCLQdBUT0BlyuRJy4/cY91t0/A7F7gN3zgcw4YNss4O/Z2jDc6wGgxfXaf4erKnMozAUO/wrsma8N1S4ewHXTgP5TATdtT3eywRBLFiwpUCF2B9D3cf3V7q7OCPfzRFx6rhqNZYglIqI6r357oPPtQNsbgfptASenyttPGSpNkFZWrYYA107T1tNKb3YZ4ZXvZZOFBTrcCmz/BCgyMEosWg0FRr2vvR+ZBUOsvdbFnt+hrbcp8QsrdbESYmNSc9CtSaD1jpGIiKimMi9qQ6Mxxv3P8GSs6rafkhFcqYmV7dJJYPfXwP4ftV0Otn5g3HENfRPo92TFoZpMhiHW3sgvq3w8kZ0EJJ8BQlrpb2oU6AmcA9YdSUB9Xw9c0zwILlJjQEREZKsdBaR3avw+4OQ67aSsuH2mP66a1p7WbwOMfA8Y8hpw6Gfg70+BlNOG79d8AAOsLYXYwMBA1U6rMoWFhaY6JqqKfOQhtbDR27UlBVdC7JrD8Vh/NFF9//vBeLU18PfEjNGRGNGxAc8pERHZTkcBWYEqauOV4LoOuKz990tPPtpPOmk7r5i7D9DjPqBBF2DeIGsfDVU3xM6ePdvYXckS/WJViP0H6D5RBdhHF+yFpsxuCem56vq593RnkCUiItvoKPDTRCDhcOm2V+6+2kV8Wg8HWg8FMhOAeQNt8BXjp5t2GWInTZpk3iOh6tfFRm9HUbEGM387Wi7ACs2VXze5fWhkOEsLiIjI+nTlAkEtgTYSWocBTfuV7ssqvdCNmYzFhQAcGmti7VHjXtp4mhKFfUdPID49t9JdJcjK7TvPpqBvS676QUREVtb3CW3/1eCWppuMRQ6JIdYeeQUAYR2Ai4dRLF0KEGrwLomZlQddIiKiWks5a9x+nW6vOsDqcCEAMsDZ0A5k2yUFjTMPGLV7aD02WSYiIhOTVo/n/gYWjgeW3lf3T6+u52xVWOZgMRyJtVeycteuL9EgfR8a+I9Wk7gqqosVgd5uqt0WEVGdV5MWT1R9xUXA8T+Avz8GYnc7zhlkmYNNYYi185FYp4SDeOPmJnh4yUk1iauiIJuWXYAf/z2PiX2bWfwwiYhsssUTg2zNFOQCBxYB26Vf6hntddK7vOtdQKsbgCV3o85jmYP9lRNERkYiJSVFf/nhhx/GpUuX9JcTExPh7e1t+iOkivk3AvybAJpiDPW7oNpohfuXLhmQPrH9WgarYPvqiiN4e9UxFBdXNl5LROQgLZ6qGql11PAft7/yTW7PSQW2/BeY3Qn4fao2wHoGAAOeA545DIyere2hyo/ayRZHYo8fP15qQYPFixfjxRdfRP369dVljUaD3FxOHrJ4v9iD0apf7IjBg1UbLelCIJO4pAZWSghkwa7PNpzGh+tPYt6WKMSm5uDD8V3g6eZi2WMlInJkpi5zMNXjGTN67eQCuLgDhTnay36Ngb6PA93vBTx8r+7Hj9rJXsoJJLSWVdWKXmSmutiDS7QLH8gnOs5OFbbRenJIazQO8sLzSw/ij0PxSMjIxZf39kSQjztfFiJyQBrbC4rVKXMw5eMZM3qtKdIG2NAOQP+ngY63AC5uFe/Lj9rJglgTWxcWPbiwW9sYurL/qQAY160xwvw88cgPe7DnfCpunbsd397fC02DfSx3vEREtuDbm4CIa4BGPbXLeMvmq/1U0WpBUVfmYEyINeXjyQQtY4z8ALjmIRmtMm5/IlsKsTLKWnaklSOvVhbSFvAK1NYqJRzU/o+4Cv1ahuDXR/vhvvm7cDbpMsbN2Y6vJvVE9yaBFjtkIiKry88CzmzQbjoyx6BRd6DxlWAr/97VNijKJ5byXBlxxh3Xnm+BUw21i9nI8zs5l9muXGfs4214UzvpqiD76pZf5vuSS79WRUI/AyzZa4iV8oEhQ4bA1VV7l5ycHIwePRru7tqPpEvWy5KFODsDEX2Ak6tVXayhECtah9XDssf7YfK3u3A4NgN3zvsHH9/RFSM6NrDIIRMRmYUEym0fGbfvLfOAvEwgdi8Quwe4dAJIj9ZuR5df2cnIEcdjK4HT64HLyUB2EnA56cpXuZwMFBkIwiXtmQ+TOv2naR+PyF5D7IwZM0pdHjNmTLl9br31VtMcFVWvLlZC7Pnt2kJ7I8ikryUP98WTi/Zhw/FEPLpwL/5zYyQeuLY5zzwR2V8/VjmWnydpA6mxn2I17ArICt4iN107C1/ur9sy4417rK0fGt7H1RMoNGLic/sxgLf09NaozjParYLv5bxHbTT8ePJvQnBrwM0bcPfWfi37ffIZ4PvRxv2sRHUlxJKN1cXKSKz8D87Ij3t8PFwxb2IPvP7bESz4Jxpv/n4UMSnZePWmSDVBjIjILvqxnv4L+OVBICcF8PADCnKq/oi8otWUPP2BFgO1m86p9cDC2ww/f5N+QHALwDsE8Akp8TX46uWkk8C8Eo9dmeumacO1IRK45xkRYjuNN/x4l6+2yiSqsyFW2metW7cOgwcPRr169UrdlpGRgU2bNmH48OHw8DCwHBuZlvwPSv7Kl4+v5C/qkFZG39XVxRlvjumIiEBvvLP6OL7dfg6xaTn45I5ucHd1Lteui+GWiMwyUakmiouBrf8FNr6tHbmUHqXjv9e2gzLFCLFPmYlelRnxjnHBk4isF2K/+OILrFy5EjfffHO52/z8/PDJJ58gOjoaTzzxhKmPkaoiowpSC3v+byB6R7VCrG5y3iMDW6JRoBem/XQA649exIiPtyAnvwiJmXmlFk6YMTqStbNEZH3ZKcCvD2trUUX3ScDI9wG3Kwu+cDUu40mol39HDI2qlx29JrKnELtw4UK8+uqrld4+depUvPHGGwyx1qqL1YXY7hNr9BA3dW6oWnBN+mYnzidnl7s9IT0Xjy7Yq1YG4yQwIrKauH3Aknu1k7DkU6gbPwS63eNYQdGUj8cFCsgRQuypU6fQpUuXSm/v3Lmz2oesWRe7o1YPI622fNxdkJ1fVGFrcKmUnfnbUbUyGEsLiMigQz8Dfo3K92CtCan53/s9sOo57Yz/wGbA+B+ABp3N80LYclA0x+Nx9JrqcoiVFlqXLl1CkyZNKrxdbmObLSuR/n0SMVOigMyLQL2wGj2M1MBeysqv9HYJsvHpudh5Nhl9W4bU4oCJyG5JX+ot7xu3747PgH//B7QeBnS5E2gzAnCtwUqBMlnrj+nA/gXay21GAuP+B3gFwGxsPSgyeBIZH2I7dOiAP//8Ez16VNyLdP369WofsgKZWRvWEbh4CIj5B4gs3/7MGDKJyxhTFuzF4Lb11RK3fVoEo0mQd5ULXxQVazhJjMjeyUjo0RXakdDLicbdp3574NIx4MQq7eYVBHS6Deh6F9Cg69VuKlW168qIBf6cCSSd0Db6v/5VoP9UbZ9sc2NQJKobIXby5MmYNm2aCqo33XRTqdt+++03vPXWW5g1a5Y5jpGMrYuVEHt+R41DrHQhMEZ6TgGW749Tm2jo74k+VwJt3xbBiAjy1u+75nC8KkGQEVybmSRmS/0t7QXPmWNLjwVWTdcGURHQBEiLNnw/GS118wL2/wgcXKLtvbpznnaTgCthttm1wPwRhrsdeAYC478r3QaLiByak0aW4jLSPffcgx9//BHt2rVD27Zt1ejbsWPHcPLkSYwfPx6LFi1CXSAtw/z9/ZGenq46L9iFQ0uBXx7Qjm48srlGDyEjpte+t0FN4qroTSFjJjL564PbOmPnuRTsOJOM/TFpKCwuvXfjQC8VZr3dXfDdjvMVPo6oySSxWo/qmrq/pSOEO1vqCUqWJW2sdn+tHQnNzwSc3bS9TDtPAOb2rd57orhI26BfAu3xP0o0/5ffXyP+Gbp7KdB6qGl+LiKqExnM6JFYsWDBAtViS4KsBFfJvxJmZ86cqUIsWTFkePhrv48/oF29S1ZiqWaQkjD4zpAA/HeZdoJYyX9WdDFx+g19cV2b+moT2fmF2HM+VQXaHVHJOHghHRdSc/DzngtoiCR0cMqs8Lnk8f63MhNDIycYF0LTYrD90Al8sSUKSSXqdkN83fHIgBbo16mtcQHKlP0tHSXc2UJPULK8xGPAyqeACzu1lxtfA9z8CRDaXnu5uvWizi5Aqxu0W04acGSZNtDqHt9UfVuJyGFUK8QKCasMrDakXJDSAPNH1ixIpcVg0LqRGORRRWBZ5wG0ufpY3u6uuK51fbWJrLxC7D6Xgg3/7sHLZ56Fp1PlK+fk5rnhqf95oVnLtmgW7INmIT5oGuyN+r4epWts02JQ9El39CvORz+5XHI9DXn4v4Cije5weWqvZUOUqcOdI4zqku2T96wspbp1lnblK3df4IbXgZ4PlK5DrU29qEzI6nm/djv6G/CTjbfIIqK6EWKTk5MRHKxtKRITE4Mvv/wSOTk5GD16NAYMGGCOYyRLBSkTPJavhysGtQ0F4l3hGVVQdYmbUwHOxcTgj+jSb0Np89VUhVpv9bWryzkML668a4JwKc5H0eUkuPg1BLISgcw4IDMByJCv8UBGvPa6lLMwyqI7tXV/0hrIN+zKFgr4hF79vqjqn69aHGVUl6zL0B9KqeeBjW9pl0nVdQG48b+Af2PzHRPfz0Rk7hB76NAhFVQluLZu3RqLFy/GiBEjcPnyZTg7O+Ojjz7C0qVLMXbs2JoeC5mT8aXPJhHkbVwbnZs7BKGPVzDikjMQl5KB5PQsuBQUIT+hEGcTinABhbjkFIPhRjxc0Q+3wiUvDdCU73NbbSoEayeu1Zq0PqsXrp2ZXVl7IX5kT+ZmzB9KOvLH2qj3gcixVzsIEBHZa4h9/vnn0alTJ1UXK5t0KBg1ahS++uordfuTTz6Jd999lyHWVn05SFuJ6uxaYnMufVkmXhjjp3sBFwljGkBTfGXTXAnK2us6GfMPJYBHTj9a+oqSpQLV5J6rHWEqhjPyPEOgqdcAHoGN4eLfEPBrANRrCBRkA39MM/xgN38GePppR3WzLl75euX7y5e0X4uqHh3WW3p/iYOsB3gHaUsD9F+Dtc3bbTn8UPXPmalKQ0z1WMb8oSTajgLGzgG8Ao07PiIiWw+xu3btwoYNG9TKXF27dsW8efPw2GOPqVFYXYjt06ePOY+Vak2jrXGTrTbSynccKKtGYzfSA1LCscyAdtFt7sgrKIBHdoLBuz+TPwXbizsiCf4oynUB0gCnC0BEoDdah/qiVZgverhHY5gRh1IU1hEujbpVvoME9nPbgO9Kt5urkGcAkJepHSGWGd6yGXEObcLZLcDyKdY+CvtiytIQa5SZDHyBAZaI6laITUlJQXh4uPre19cXPj4+CAoK0t8eGBiIzMyKZ6KTDbh3pXZWcXFhia2o9FeZjWxMYBn9MRDcWhs61eak/SrRVX3vBCSdAn59yPBj3b8aaNRDG1wraV7uGrvvykhy1SbePAJdiprhVGKWdruYidTsAkSnZKvtr+OJ6OB0FsOMGO09EpuBzo2q2EF+Ro96MMq9K4DwzkBeOpCdoh0R03+9skkNoq4Hp63Y85121FreG8aQoE62U6eem66tAU+V7RxwYbdtvjqmXN6ViBxKtSZ2lV2VqapVmsgGV/WSyUimIL1oG3Y1sJOR7w1pBSb/QFXBxcj3WfcmgejesHmp65Kz8nDyYhZOJ2aqYHv6VA5yM92q7pqgcUNUtgdMuiK7BHT5eFa24Jblb4/bb1yI1ffWNCP5o+bPGcD2T7WX24wCzkgLCANhavULwP1/cBTPGqTv6rGVV0LrOW1wleVh7YGpl3clIodRrRB73333wcNDGzhyc3MxZcoUNSIr8vJsuKaPHFawrwf6ytZSO4qz40wDXP/lhwispH+tSNXUQ/yaZCw4th1D2odhSPtQVY5Q7o82a4wgyYIWt38HNO4Js8jLAn59GDjxh/byoJe0Hy+nX6g8ZCSfBn6fBiQeAb67WTvyLPW+lmDPbcl+vh/w8NX2T9XVpTvJ97rNVft6GGPL+5X3Vg1sDgQ2066ctfc72CQu70pE5gyxkyZNKrd6V1n33ntvTY6BasOUQcoBHktW+NL4N8bRSlYlUw/l7ARNsQa7z6eq7b01xxER5IUh7cJwfbtQ9G4RBA9XF/0IkkkWYTCWhMmvhwLXPgMMfLHybgc1euxYYNEEIOEQ4OKhndwj69wbChkyKi+lKhJgEw5eDbI+Zv7419bakl1OAk7/qV1e1RipUaZ77sa9tCUrQc2vhlbZJCSXHO231RBLRGTuZWcdhd0tO2uLM6Ft+LHWHI7Howv2VroqmSyH26lxADYcT8Rfxy5i+5lk5BcWl+pjK4s7XN9eW57xwtKD5QJxtZfWNSaQSbCU1Y50o6RhHbVr04d3Qq3F7QN+vAPISgC8Q4A7FwER11TvMRKPA9+NBi4nAqEdgEkrAZ8QmI2EsnkDDe/38GYjyl9q8B6TJVkltJ9aB5xcC8TuMW75VJ1RH2qDpqZMbbp0+9BdlvKArR+Y5mc09fkiIrJyBmOIreUJJPskQXbmb0cRn361xrSBvydmjI4sFzplad2/TyerQCuTwy5lGlc6I0E23N8T21643rRL6x5Zrp1wJYFLJsQNehHoPxVwqfbaJVpHV2pLCApzgPrtgbuWAIFNa/ZYl05qg6yEYXksCbKmqsU2ZygzdlT3oc1A8kltcD21XttqrST5g0Jqxvf9YJrjssbPyAU1iMiKGGIteALJfhUVa7DzbAoSM3MRWs9TlRoYCpvFxRocjkvHX8cSsfJAHM4mXTb4PM/c0AaD2tZHgwBPhPh4wLmS59CNEBs1qis9a3+benVUtlFP7ahsSGsYTT6E2fYR8NdM7WUZ5b1tvrY/bm0knda2HpOV0kLaAJN+0y72YGrGBjz5eF0m0/k10m7+8rXh1cvykbuxjyU1qyUX03DzAVoOBloPA1oP1T6uKYOntUebiYgszK5C7Jw5c/DBBx8gPj4eHTp0wOzZs3HddddVuO+mTZswePDgctcfO3YM7dq1U99/++23uP/+Es3lr5ClcT09PY06JoZYMsaK/bF4evH+ap0sqbcN8/NEwwBPhPt7qdHfcD/ZPPDqiiNIvpxv/Kiu/OoeWAysfh7IywBcvbRr3F/zcKXtyvQK84HfnwH2L9BelvsMf6fmo7llJZ/RjshmxALBrbRBVgKeqchywutnAId+qv1jefhrJ6LJjH5jBLUE2gzXBtem/cp317D3PrFERFZUnQxmon+xambJkiWYOnWqCrL9+/fHF198gZEjR+Lo0aNo0qRJpfc7ceJEqR+sfv36pW6X22SfkowNsETGktFbY7Ss74OsvEIkZuahsFiD2LQctQHGt0CSvzSl9EFGjnWdFlSv2q53As2vA1Y8DkRtAta8ABz/XTspS6JvRaNuuRnAuv8ACQe0/X1HvAf0fhgmJSOf9/2hDbLSveDbG4FJv2tHQWsbjv+erQ3vxq6YNvID7cx8CdSyyQQ2CcGySe9e3WaMCQuB9jdZrmUU208REdlmiJ01axYeeOABPPjgg+qyjMKuXbsWc+fOxTvvvFPp/UJDQxEQEFDp7dIKSbcwA5G5SPmBjKQmVNLpQDd6uu6ZgWr0tKCoWNXTxqfnqEAq95OvcvlIXAbOJ2cbfE4pfSjHvzEwcTmw+2tg3avAua3A5320fV0NLVQwZo42CJuDzJRXQfYmICUK+HaUNsjWZMQw/iCwbRZwdIV24pMI76IN4obIBLXKPmqXBRokzEZtBlY/Z/ix5FxbumUU208REVXIwGeO5pOfn489e/Zg2LDSi4DK5e3bt1d5327duqFBgwYYMmQINm7cWO72rKwsNG3aFI0bN8ZNN92Effv2Vfl40uNWhq9LbkSGSDCViWCibJWr7rLcrvv4383FGQ0DvNCjaRBu6twQD17XAq/eFIk5d/fAu7d0rt3or4zK9noQmLINiOgDFFw2bqUtaY1lTjJBTIJsQFNtE34JsqnVWHL3/HZgwa3AF9cBR5ZpA2ybEcDktcDNn9T++GTVtfptq9+JgYiIHDfEJiUloaioCGFhYaWul8sJCQkV3keC67x58/DLL7/g119/Rdu2bVWQ3bJli34fqY2VutiVK1di0aJFqoxAShVOnTpV6bHIqK/UX+i2iAjWlpFxZKKVTLiSEdeS5LLR7bVKjOoa6mHw+8E4XM4rrPpj/PtXAb2NWD7YUgKaaI9JJlilRQPfDAeOr9JOWqpok31OrAG+Hg7MH6ntvSplDx1vA6b8re2e0KTP1f7BVeFypUREdZbVJnbFxcWhUaNGatS1b9+++uv/7//+Dz/88AOOHz9u1OOMHj1alQ9IaK1IcXExunfvjgEDBuCTTz6pdCS25IpjMhIrQZbdCcicnQ6q07+25OUmQd747+1d1HPYVU9Q+dhegml6tIEdS/zELu5A17uB/k8BQS3MN9veFs8XEZEDyrCHiV0hISFwcXEpN+qamJhYbnS2Kn369MGCBVdmWFfA2dkZvXr1qnIkVpbS1S2nS1QTElj1E65qOapbtn+tjOpKWYKvhxueX3oA0SnZmDBvByb3b47nhreFp5uLfbxo0p1g9GxgwS0GdtRoOy1c8xDQ9/Gq23OZql7UGksIExFRrVgtxLq7u6NHjx5Yv349xo0bp79eLo8ZM8box5F6VykzqIwMNO/fvx+dOplgVSMiM5MgOzQyvNJR3TXPDMBbvx/FT7sv4OttZ7HxRCI+vL0LujUJtI/XxtgQePfP2q4LlsIuAEREdseq3QmmTZuGiRMnomfPnqqkQOpdo6OjMWWKtp7vpZdeQmxsLL7//nt994JmzZqpfrIyMUxGYKU+VjadmTNnqtHZ1q1bqyFpKSGQEPv5559b7eckMtWorp+nG96/rQtGdmyAF389iKhLl3Hr3O14ZGBLTL2hNTxc7WRU1pgJV5bGLgBERHbFqiF2woQJSE5OxhtvvKEWO+jYsSNWrVqlOgsIuU5CrY4E1+nTp6tg6+XlpcLsH3/8gVGjRun3SUtLw8MPP6zKFKSmQjoZyMSva67h7GOqOwa3C8W6qQPx+m9HsGxfLOZuOqOWxf3w9q7o1Njf2odHRERkdlZfscsWccUusidrjyTglWWHkJSVr0ZxHx/cCk9094D73F62t9ITJ1AREZG9T+wiItMY3iEcvZoF4dXlh/HHoXh88tcp/HnUDx+P34xLF2PxxZYoFXB1Qnzd8ciAFujXqS2XKiUiIrvFEEtUBwT5uOPzu7tj5ME4FWaPxmdgxLcZKFKLW5Ve6tUpE9jyRx7mBrpiROUL3xEREdk0qy12QESmJyuBrX1mAG5oH3olwJanqx+SVl7S39aiuEABERGZCEdiieoYacv1wLXN8eexxEr3kegqvWillVdt+9tWC1tZERGRiTDEEtVBiZl5Ru53dVEFi2ErKyIiMgGWExDV0dFYYwT7uJv9WIiIiMyBIZaoDpJVvhr4e0K7zlfl/rP8MH4/GIdiS9fGEhER1RJDLFEdJP1iZ4yOVN+XDbK6y74erjiXnI0nftyH0Z9tw+aTl9QyzURERPaAIZaojhrRsQHm3tMd4f6lSwvk8v/u6Y5/Xh6CZ25oo8LskbgMTPpmJ+6Y9w/2nE+12jETEREZiyt2VYArdlFdIm20pAuBTOKSWlkpNZCRWp3krDzM2XQGP/xzHvmF2r5cN7QPw3PD26JteL1qPRYREZGlMhhDbC1PIFFdEZuWg4//PImley5ASmSdnIBxXRvhmaFtEBHkjTWH41VvWWnNpSN1t1K2IKO+REREtcUQa8ETSFTXnE7MxIfrTmL14QR12c3FCde2CsHGE5fK7asbg5WyBQZZIiKyZAZjTSwRldIqtB7m3tMDKx7vr8JrQZGmwgBr9dW/iIjIoTHEElGFukQEYMGDvfHKqPZVnqGSq38RERFZCkMsEVUp1M/DqDN0NimLZ5KIiCyGy84SkUlW/3pl2WEs3xeHIe1DMaR9GFrW94GTzA6rBDsdEBFRbTDEEpFRq38lpOfqa2DL/Y/E2QmF0n7rXIra3ll9HM2CvVWrLgm0PZsFws3l6gc/7HRARES1xRZbFWB3AqLSJHQ+umCv+l5TSXeCDg39seF4Iv48dhH/RCWrCWE6fp6uGNRWRmhDVdid/tOBcoGYnQ6IiCiDfWJrhyGWqLzqjJ5m5RVi68lL+PNYIjaeSETK5XyjTqnTlRXFtr1wPRdRICJyQBkMsZY7gUSOpCZ1rHKffdGpKtD+diAWsWlXQ3BlFj3UB31bBpvwyImIqK5lMNbEEpHRJLBWN1zKfXo2C1Jb+wb18PTi/Qbvs/1MEpe0JSKiKjHEEpHNdTr4dMNpLPw3GkPbh2F4xzD0axkCTzeXSvdnpwMiIsfDEEtEFmNMpwMvNxe4uzqpOtolu2PU5uPugkHtQjGiQzgGta2Pep5u+v3Z6YCIyDGxO0EFWBNLZN1OB9KaS2pv1x5JwNojF5GQcbWO1t3FGf1bBWN4h3A4OzvhhaUH2emAiKiO4MQuC55AIqq+6oyeFhdrcDA2/UqgTUDUpctGPQc7HRAR2R+GWAueQCKqmZrWsZ5OzFSjs0v3XMDZJMOBlp0OiIjsB7sTEFGd7HQgWoXWU1vjQC+jOh3M/vMkYtMi0Lt5kLpPVUvhCk4SIyKyD5zYRUR1utPBv2dT1CYa+nuid4tgNeorobZ5iE+pUMtJYkRE9oMTuyrAcgIi2ycjpte+t6HSTgcSTQN93HF7z8bYdTYFBy+kqyVvS6pfz0MfaGWZ3Ld+P8pJYkREVsSaWAueQCKy7U4Huoli2fmF2Bedhn+jktXI7L6YNOQXFhv1PJwkRkRkGQyxFjyBRGRdNS0ByC0owoGYNH0rr8NxGQafi5PEiIjMixO7iMhhSFAdGhle7U4HsgKY1MfK1iTY26hJYnM2nUaxRqMe383F2YQ/BRERVRcndhGRw3Y6qO4ksa2nktTm7+WmFmQY3iEMA9rUr3RJXHY6ICIyH4ZYInJ4hpbDVZPEvN0wpH0Y/jqeqJbE/WXvBbXJMrmyFK6sIDa4XagKuIKdDoiIzIvdCSrAmlgix2PsJLHComLsPp+q6mjXHbmI2LQc/b5uLk7o0yIYEYFe+HFnTLnnqGjCGRERXcWJXbXEEEvkmKo7eqrRaHAkLgNrDmuXxD2VmGW2TgcsTSAiR5BRjcn1HImt5QkkorqlNmHxzKUsfLklCot3lR+FLeupIa1wU+eGaBbsA3fXqieJsTSBiBxFBkOs5U4gEVFJK/bHGtXpQMfV2UmtHNYmvB7ahNZDmzBf9X3TIG+4ujjryxzK1uqyNIGI6iK22CIishJjOx20CvVBQnoesvIKVRmCbH8gXn+7u4szmod443xKdoWTzTRXgqyUP0iLseqUJhAR1QXsTkBEZOFOB1ITu3bqQEjulPrbExczcepiJk5ezMJJ9X0WcgqKcOJi1TW28vhyfyl/qE6LMdbXElFdwJrYCrCcgIgstRxuRYqLNarrwfc7zuHLrWcNPl+Irzv6twpBt4gAdGsSiPYN/Cqts2V9LRHZMtbEWvAEEhGZKyzuOJOMO7/8p9onWAJsp0b++lDbrUmAem7poMD6WiKyZQyxFjyBRETm+the7n/texuqLE0I9fPAe7d0xoEL6dgfk4p9MWlIyy4ot29oPXek5xQir7DYpK2/iIhMiRO7iIjqwHK4cn8ZuZXRU6dKShNm3twBg9qFqk3Xu/Zccjb2RadiX3Qa9sWk4lh8JhIz881SX0tEZC2c2EVEZMOk9EBqaMuWJoRXUprg5KRt2SXbLd0bq+ty8oswd/MZfPLXKYPPF19iBTIiIlvGiV0VYDkBEdW10gRj62t9PVxU+JWtS2N/FYqJiCyFNbEWPIFERPbAUH2tkExcXOLGlvW1o7njujVCwwAvs4RrIqKSGGJriSGWiByx9ddnd3WDr6cbft17QXUyyC3QTgKTwdi+LYJVoB3ZMRw+HtpKNLbrIiJTY4i14AkkIrInxgbPzNwCrD6coALtP1Ep+uu93FxUkI0I8lY1tqZcDpejukSUUY0MxprYCjDEElFdVt2wGJOSjeX7YvHrvlicTbps8PFr0q6Lo7pEJBhia4khloioPGnfJX1o52w8jT+PJRo8Rff1a4YeTQMR7OOOIF93BPt4INDbDa4uzhWWOZhyVJeI7BNDrAVPIBGRo1mxPxZPL95f4/sHeLshyEdCrbsKtdtOJyM7v6jCfbkIA5FjyahGBmOfWCIiqhYpQTDGNc0C1ayw5Kw8pFzOR1pOATQaqBXFZIu6ZLg0QbcIw7bTlzCwjXZBB2Owvpao7mOIJSKiapEaWpkMVtVyuFITu+jhvqVqYguLilWQlUCbnJWP5Mt52HTiEpbuuWDwOSfP340ezQLRp3kQ+rQIRrcmgfByd6lwX9bXEjkGTuyqAMsJiIhq167L2DpWYxdhKMvNxQldIwLQu3mwCrXdmwbA292V9bVEdo41sRY8gUREjsoUI56GFmHQjer+8EBv7DqXgn+jklXLr4SMq88pXJ2d0LmxP05czMTlPNbXEtkrhlgLnkAiIkdmitrT6o7qSpeE6JRs/BOVjH+jUtTXuBJB2pBFD/VB35bBRu/P+loiy2GIteAJJCIi647qSqi9kJqDOZtOY9HOGIPPdV3rEIzu3BCRDf3QOswXHq4uZjkuIqo+hthaYoglIrK82o541qS+VmprW4XWQ4eGflc2f7RvUA/1PN1YX0tkBQyxFjyBRERkGwzV14oALzfc0r0Rjidk4khcBtJzCircr2mQFy5m5iG3oLjC29m/lsj6Gaz0silWMGfOHDRv3hyenp7o0aMHtm7dWum+mzZtgpOTU7nt+PHjpfb75ZdfEBkZCQ8PD/V12bJlFvhJiIjImmTUVj7mF2XHb52ubO/e2gmvje6AHx/qg/2vDcW2Fwbji4k98NSQ1rihfagqFRDnU3IqDbAl+9fKyDERWYdVQ+ySJUswdepUvPLKK9i3bx+uu+46jBw5EtHR0VXe78SJE4iPj9dvrVu31t+2Y8cOTJgwARMnTsSBAwfU1/Hjx+Pff/+1wE9ERETWJHWqMhFMOhqUJJfLThCTQZDGgd4Y3iEc04a2wVeTemHHS0Ow99WheGxQS6OeLzrF8IINRFQH+8T27t0b3bt3x9y5c/XXtW/fHmPHjsU777xT4Ujs4MGDkZqaioCAgAofUwKsDEWvXr1af92IESMQGBiIRYsWGXVcLCcgIrJvlqqvdXdxxuguDTG+Z2P1HBKMiaiOlxPk5+djz549GDZsWKnr5fL27durvG+3bt3QoEEDDBkyBBs3bix1m4zEln3M4cOHV/mYeXl56qSV3IiIyH5JYJU2WmO6NlJfq9v2S7cqWVX3ksfMLyrGL3svYMK8fzD4v5vw+cbTqia3qnAtAXnF/lj1VS4TkZ0tO5uUlISioiKEhYWVul4uJyQkVHgfCa7z5s1TtbMSPH/44QcVZGWEdsCAAWofuW91HlPIqO/MmTNN8nMREVHdqa+V/rVOlfSv/ezObgj188RPu2Lw+8E4nEvOxgdrT+DDdScwqG2oGp29vl0Y3F2140Vs10VUR0KsTtmPXqS6obKPY9q2bas2nb59+yImJgb//e9/9SG2uo8pXnrpJUybNk1/WUZiIyIiavTzEBFR3aqvLdsnNrxMn9geTQPx2uhIrDoUj592x2DXuVRsOJ6otmAfd4zr1ggNA7zw5u9Hy3VNkFFbCcrGLtNLRDYQYkNCQuDi4lJuhDQxMbHcSGpV+vTpgwULFugvh4eHV/sxpYuBbERERCVJsBwaGW6wvtbHwxW394xQW9SlLPy85wJ+2XMBiZl5+Grb2UpPqoRaeSQJyvI81S17IHJkVquJdXd3V2UB69evL3W9XO7Xr5/RjyNdDaTMoOTobNnHXLduXbUek4iIqKb1tS3q++KFEe2w/cXr8fWknujZNLDK/WvTros1tuTIrFpOIB/hSwusnj17qvAp9a7SXmvKlCn6j/ljY2Px/fffq8uzZ89Gs2bN0KFDBzUxTEZgpSesbDpPP/20Ki147733MGbMGKxYsQJ//vkntm3bZrWfk4iIHI+rizOGtA9DVl4hdp9PNbj/f5YfQp8WwWgTVg+tQ33ROqweQnzdKy2HY40tOTqrhlhph5WcnIw33nhD9Xvt2LEjVq1ahaZNm6rb5bqSPWMluE6fPl0FWy8vLxVm//jjD4waNUq/j4y4Ll68GP/5z3/w6quvomXLlqofrbTzIiIisjQpQTDGmUuX1VZSoLcbWofWQ+swXxVsJeC2CvPFnnOpeGzhXtbYkkOzap9YW8U+sUREZKnlcGWcNdjXHS+NbIfTly7j1MUsnErMRHRKNir7F1oGZyu97crks20vXM8aW6rTGczq3QmIiIgcvV3XW2M7lutOkFtQhNOJWWo7eTETpxKzcOpipmrlVdXwk67GdtneCxjXvbHRQba2C0QQWRpHYivAkVgiIjI1U9WwLt0Tg+k/HzRqX18PV3Rq5I8uEQHoemUruySvKY+NyJIZjCG2lieQiIjIWKYY7azOkriyolhZYX4eKsyqYNs4ABczcjHtpwPlSh10R8UetmRJDLEWPIFERES2VmMro62bpg/C2eTL2B+dhgMX0rA/Jh0nEjJQnZVua1pfy9IEqimG2FpiiCUiIlsmH/9LjS0qqbGtbPQ0O78Qh2MzcCBGQm0a/o1KRtLlfIPPd0/vJri+fSha1vdF40DvKgMtSxOoNhhia4khloiIbJ0pwuKK/bF4evH+aj2vu6szWoT4qEDbMtQXLetf+b6+LzafTFThmqUJVFPsTkBERFTHGbskril62PZpHoS0nAJEJV1GfmExjidkqq0seeqKqhW4vC6ZA1tsERER2fmSuDUloVdGbw3V1y58qI96Lql1jU3NwelLmTiTKIszaFuAnb6UhbTsgirrbXWtv34/EIebuzasdCWyslhfS5Vhd4IKsJyAiIgcRU3ra8v68d/zeHnZYaOeM9jHXd/2q1uTAHRuHAB/L7cKj42tvxxLBltsWe4EEhER2TtThEVjW3+5OMvoavnrpba2a0QgujYJQLeIAJxLvownf9zH+loHk8EQa7kTSEREVBfU9mN7Y1t//TltIE5czFStv6RDgmyyxG51sPVX3cWJXURERGTR+lpjlteV2308XNG9SaDadJKz8vSBVrbd51KQU1DBcG2Z+tqvtkZhbLdGCK3nYbDGlqUJdQ9rYivAkVgiIqKaMUVYXL4vFlOXGN/6K8DbDW3C6qGtbOHaTS7r6mx1db9s/WX7OBJLREREdtv6K8zPuNZfEo5l2VzpjCDPJ1vZ21uH+mLP+VSTt/5i1wTrY4stIiIissvWX7IcbkFRsWrzdfJipqq1PZGQiZMJmYhLz1WjwSVHhKsqTfhu+1kVwCVAGwqzLE2wDSwnqADLCYiIiOy79VdGboEKsz/tjsFPuy8Y/byuzk5oGOCFiCAvNA7w1n4N9EbjQLnOG3vOpeLxH1maYC7sTmDBE0hERET23/orzM8DyVn5KKxqxQYzdU2gq1gTS0RERHbPFPW11SlNEFJjeyE1BzEp2errhdRsxKRqv49LyzFqVTI53tqUU5BxWBNLREREcPTWX7pgLKUEskn4LWvZ3gt45qcDBp8zOuUyQ6wFOFviSYiIiIisOaIrNbQy4lqSXDZ2WV3t/l5G7Tdz5RHMWncCKZfza3S8ZBxO7KoAa2KJiIjqHnOvSibk8WQ/4eXmgjuvaYKHBjRHAyMDsKPL4LKzljuBRERE5DgMdU34/K7ucHYGPt94Bodi09V1bi5OuKVbY0wZ1BLNQ3zMenxFtQzq1sYQa8ETSERERI7FmK4JGo0GW08lYc6m0/gnSrsIg2TJUZ0a4NFBLdGhob/Jg+caE3RzsDaGWAueQCIiInI81Qmee86nYM7GM/jreKL+usFt6+Pxwa2QlJVnkuC5po4srcsQa8ETSERERGSMY/EZmLvpDH4/GFdlq67qBs+iK7W6la1OZk/9axliLXgCiYiIiKrjXNJlzN18Gkt2Vb2SmEwMG9I+FHmFxdqtoAi5V77mlfh6Oa9QXW/Ioof62HzrL4ZYC55AIiIiouoydiUxU2oXXg9juzVC/5YhiGzoZ3BU1hqTxLhiFxEREZENk2BojFu6NULPZkHwcHWGp5uL+urhdvV7+Xo0Lh1TlxhehOF4QibeXX1cfe/n6Yo+LYLRv1UI+rUMRqtQXzg5OdnVJDGu2EVERERkYTKyaYzbe0YYLAFoWd8X7605UeXSuiG+HnhkYAv8E5WMf6NSkJFbiHVHL6pN1K/nocKsbAVFGry6/HC5x5LHl8ljtjJJjIsdVIDlBERERGROhhZOqO5krDUG+teWDJ6FRcU4HJeBv08nqbKGXedSVG2tMcw9SYw1sRY8gUREREQ1UZ3gaezjzaxBCUBeYRH2Radh++kkrDmSgJMXs6w2SYw1sUREREQ2ToKlBNWywTO8hrWnIzo2wNDI8GpPxvJwdVH1sbK1DPXF04v3m6ym15xYE0tERERkJTUNnpWR+9VmhNTYWl1j9zMnhlgiIiIiK6pt8DQlCdBSgmCoVlf2szZnax8AEREREdlOoJ4xOlJ9X3YsWHdZbreFlb8YYomIiIioXK2ujLiWJJdtpb2WYDkBEREREZm1VtccGGKJiIiIyKZrdSvCcgIiIiIisjsMsURERERkdxhiiYiIiMjuMMQSERERkd1hiCUiIiIiu8MQS0RERER2hyGWiIiIiOwO+8RWQKPRrhackZFh6deDiIiIyGFlXMleuixWFYbYCmRmZqqvERERpn5tiIiIiMiILObv71/lPk4aY6KugykuLkZcXBzq1asHJycni/zVIYE5JiYGfn5+Zn8+4rm3FXzv89w7Ir7vef4dVYYReUdiqQTYhg0bwtm56qpXjsRWQE5a48aNYWnygjLEWgfPvXXx/PPcOyK+73n+HZWfgbxjaARWhxO7iIiIiMjuMMQSERERkd1hiLUBHh4emDFjhvpKPPeOhO99nntHxPc9z7+j8jBx3uHELiIiIiKyOxyJJSIiIiK7wxBLRERERHaHIZaIiIiI7A5DLBERERHZHYZYK5szZw6aN28OT09P9OjRA1u3brX2ITmE119/Xa3GVnILDw+39mHVSVu2bMHo0aPV6itynpcvX15udRZ5PeR2Ly8vDBo0CEeOHLHa8Tra+b/vvvvK/S706dPHasdbl7zzzjvo1auXWv0xNDQUY8eOxYkTJ0rtw/e/9c493/vmMXfuXHTu3Fm/oEHfvn2xevVqs7znGWKtaMmSJZg6dSpeeeUV7Nu3D9dddx1GjhyJ6Ohoax6Ww+jQoQPi4+P126FDh6x9SHXS5cuX0aVLF3z22WcV3v7+++9j1qxZ6vZdu3apPyaGDh2qlh0k859/MWLEiFK/C6tWreKpN4HNmzfj8ccfxz///IP169ejsLAQw4YNU6+JDt//1jv3gu9905MVT999913s3r1bbddffz3GjBmjD6omfc9ryGquueYazZQpU0pd165dO82LL75otWNyFDNmzNB06dLF2ofhcOR/OcuWLdNfLi4u1oSHh2veffdd/XW5ubkaf39/zf/+9z8rHaXjnH8xadIkzZgxY6x2TI4kMTFRvQabN29Wl/n+t965F3zvW05gYKDmq6++Mvl7niOxVpKfn489e/aovwxLksvbt2+31mE5lFOnTqmPM6Sc44477kBUVJS1D8nhnD17FgkJCaV+D6QJ9sCBA/l7YEGbNm1SH7m2adMGDz30EBITEy359A4jPT1dfQ0KClJf+f633rnX4XvfvIqKirB48WI1Ai5lBaZ+zzPEWklSUpJ6ccPCwkpdL5flBSbz6t27N77//nusXbsWX375pTrn/fr1Q3JyMk+9Bene6/w9sB4pYVq4cCE2bNiADz/8UH28Jx//5eXlWfGo6h4ZCJ82bRquvfZadOzYUV3H97/1zr3ge998pDzP19dXBdQpU6Zg2bJliIyMNPl73tVkR0w1IpMoyv6ylb2OTE/+56XTqVMn9Rdiy5Yt8d1336n/2ZFl8ffAeiZMmKD/Xv6B79mzJ5o2bYo//vgDt9xyixWPrG554okncPDgQWzbtq3cbXz/W+fc871vPm3btsX+/fuRlpaGX375BZMmTVJ1yqZ+z3Mk1kpCQkLg4uJS7i8P+Riv7F8oZH4+Pj4qzEqJAVmOriMEfw9sR4MGDVSI5e+C6Tz55JNYuXIlNm7cqCa96PD9b71zXxG+903H3d0drVq1Un8US6cImVz68ccfm/w9zxBrxRdYWmrJrMmS5LJ8rE2WJR+dHjt2TP1PjCxH6pHlf2olfw+kXlz+YufvgXVISU1MTAx/F0xARpdkFPDXX39V5Rryfi+J73/rnfuK8L1v3tdD/p019Xue5QRWJB9bT5w4Uf2lIh9nz5s3T7XXkvoRMq/p06er3plNmjRRfwG+9dZbyMjIUB95kGllZWXh9OnT+stS2C8fM8kECzn/0mbu7bffRuvWrdUm33t7e+Ouu+7iS2Hm8y+b9Gu89dZbVWg9d+4cXn75ZfVJ0bhx43j+a0laPP34449YsWKF6leqG33y9/dX/THl41O+/61z7uX3gu9985D/h0jJXkREhGqbJRO7ZALdmjVrTP+eN3EXBaqmzz//XNO0aVONu7u7pnv37qXaf5D5TJgwQdOgQQONm5ubpmHDhppbbrlFc+TIEZ5yM9i4caNqbVN2k/Y2QlquSMszabvi4eGhGTBggObQoUN8LSxw/rOzszXDhg3T1K9fX/0uNGnSRF0fHR3N828CFZ132ebPn6/fh+9/65x7vvfNZ/LkyfpcI/9vGTJkiGbdunVmec87yX/MkcSJiIiIiMyFNbFEREREZHcYYomIiIjI7jDEEhEREZHdYYglIiIiIrvDEEtEREREdochloiIiIjsDkMsEREREdkdhlgiIiIisjsMsUREpMiSkMuXL+fZICK7wBBLRGQD7rvvPhUiy24jRoyw9qEREdkkV2sfABERaUlgnT9/fqnT4eHhwdNDRFQBjsQSEdkICazh4eGltsDAQHWbjMrOnTsXI0eOhJeXF5o3b46ff/651P0PHTqE66+/Xt0eHByMhx9+GFlZWaX2+eabb9ChQwf1XA0aNMATTzxR6vakpCSMGzcO3t7eaN26NVauXGmBn5yIqPoYYomI7MSrr76KW2+9FQcOHMA999yDO++8E8eOHVO3ZWdnq5FcCb27du1SAffPP/8sFVIlBD/++OMq3ErglYDaqlWrUs8xc+ZMjB8/HgcPHsSoUaNw9913IyUlxeI/KxGRIU4ajUZjcC8iIjJ7TeyCBQvg6elZ6voXXnhBhVcZiZ0yZYoKojp9+vRB9+7dMWfOHHz55Zdq35iYGPj4+KjbV61ahdGjRyMuLg5hYWFo1KgR7r//frz11lsVHoM8x3/+8x+8+eab6vLly5dRr1499TiszSUiW8OaWCIiGzF48OBSIVUEBQXpv+/bt2+p2+Ty/v371fcyItulSxd9gBX9+/dHcXExTpw4oQKqhNkhQ4ZUeQydO3fWfy+PJSE2MTGx1j8bEZGpMcQSEdkICY1lP943RMKpkA/VdN9XtI/UyRrDzc2t3H0lCBMR2RrWxBIR2Yl//vmn3OV27dqp7yMjI9WorJQA6Pz9999wdnZGmzZt1Ihqs2bN8Ndff1n8uImIzIEjsURENiIvLw8JCQmlrnN1dUVISIj6XiZr9ezZE9deey0WLlyInTt34uuvv1a3yQSsGTNmYNKkSXj99ddx6dIlPPnkk5g4caKqhxVyvdTVhoaGqi4HmZmZKujKfkRE9oYhlojIRqxZs0a1vSqpbdu2OH78uL5zwOLFi/HYY4+p9lsSZGUEVkhLrLVr1+Lpp59Gr1691GXpZDBr1iz9Y0nAzc3NxUcffYTp06ercHzbbbdZ+KckIjINdicgIrIDUpu6bNkyjB071tqHQkRkE1gTS0RERER2hyGWiIiIiOwOa2KJiOwA16UhIiqNI7FEREREZHcYYomIiIjI7jDEEhEREZHdYYglIiIiIrvDEEtEREREdochloiIiIjsDkMsEREREdkdhlgiIiIigr35f7MhIXqy9HZPAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 700x420 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(7, 4.2))\n",
    "plt.plot(train_losses, label=\"train loss\", marker='o')\n",
    "plt.plot(test_losses, label=\"test loss\", marker='s')\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"BCE Loss\")\n",
    "plt.title(\"Contact Predictor Training\")\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1babe136",
   "metadata": {},
   "source": [
    "## 6) Predictions on Test Proteins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "cf6f1efd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted contacts: 417\n",
      "True contacts: 906\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@torch.no_grad()\n",
    "def predict_contacts(model, x, device, threshold=0.5):\n",
    "    \"\"\"Predict contact map from input features.\"\"\"\n",
    "    model.eval()\n",
    "    x = x.unsqueeze(0).to(device)  # Add batch dimension\n",
    "    logits = model(x)\n",
    "    probs = torch.sigmoid(logits)\n",
    "    predictions = (probs > threshold).float()\n",
    "    return probs.squeeze(0).cpu().numpy(), predictions.squeeze(0).cpu().numpy()\n",
    "\n",
    "# Get a test sample\n",
    "x_sample, y_sample = test_ds[0]\n",
    "prob_map, pred_map = predict_contacts(model, x_sample, device, threshold=0.5)\n",
    "\n",
    "print(f\"Predicted contacts: {pred_map[0].sum():.0f}\")\n",
    "print(f\"True contacts: {y_sample[0].sum():.0f}\")\n",
    "\n",
    "# Visualize\n",
    "fig, axes = plt.subplots(1, 3, figsize=(14, 4))\n",
    "\n",
    "axes[0].imshow(y_sample[0], cmap='binary')\n",
    "axes[0].set_title(\"True Contact Map\")\n",
    "axes[0].set_xlabel(\"Residue j\")\n",
    "axes[0].set_ylabel(\"Residue i\")\n",
    "\n",
    "axes[1].imshow(prob_map[0], cmap='viridis')\n",
    "axes[1].set_title(\"Predicted Contact Probability\")\n",
    "axes[1].set_xlabel(\"Residue j\")\n",
    "axes[1].set_ylabel(\"Residue i\")\n",
    "\n",
    "axes[2].imshow(pred_map[0], cmap='binary')\n",
    "axes[2].set_title(\"Predicted Contacts (threshold=0.5)\")\n",
    "axes[2].set_xlabel(\"Residue j\")\n",
    "axes[2].set_ylabel(\"Residue i\")\n",
    "\n",
    "for ax in axes:\n",
    "    ax.set_aspect('equal')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a90c6b",
   "metadata": {},
   "source": [
    "## 7) Evaluation Metrics\n",
    "\n",
    "Compute precision-recall curve and AUC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1cb6ff12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision-Recall AUC: 0.2594\n"
     ]
    }
   ],
   "source": [
    "# Collect all predictions\n",
    "all_probs = []\n",
    "all_labels = []\n",
    "\n",
    "with torch.no_grad():\n",
    "    for x, y in test_loader:\n",
    "        x = x.to(device)\n",
    "        logits = model(x)\n",
    "        probs = torch.sigmoid(logits)\n",
    "        all_probs.append(probs.cpu().numpy())\n",
    "        all_labels.append(y.numpy())\n",
    "\n",
    "all_probs = np.concatenate(all_probs, axis=0).flatten()\n",
    "all_labels = np.concatenate(all_labels, axis=0).flatten()\n",
    "\n",
    "# Precision-Recall curve\n",
    "precision, recall, thresholds = precision_recall_curve(all_labels, all_probs)\n",
    "pr_auc = auc(recall, precision)\n",
    "\n",
    "plt.figure(figsize=(7, 5))\n",
    "plt.plot(recall, precision, label=f\"PR curve (AUC={pr_auc:.3f})\", linewidth=2)\n",
    "plt.xlabel(\"Recall\")\n",
    "plt.ylabel(\"Precision\")\n",
    "plt.title(\"Precision-Recall Curve (Contact Prediction)\")\n",
    "plt.legend()\n",
    "plt.grid(alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "print(f\"Precision-Recall AUC: {pr_auc:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d7cb2b",
   "metadata": {},
   "source": [
    "## 8) Key Insights\n",
    "\n",
    "**What we built:**\n",
    "- A CNN-based contact predictor inspired by Conf4/Conf5 from Chapter 7\n",
    "- Encoder-decoder with skip connections (U-Net style)\n",
    "- Dense predictions (pixel-to-pixel) for contact maps\n",
    "- Trained on synthetic protein data\n",
    "\n",
    "**Real systems (trRosetta, OmegaFold, AlphaFold2) additionally use:**\n",
    "- Multiple sequence alignments (MSAs) to capture evolutionary information\n",
    "- Attention mechanisms to model long-range dependencies\n",
    "- 3D convolutions and graph neural networks\n",
    "- Training on millions of natural proteins\n",
    "- Iterative refinement of structure predictions\n",
    "\n",
    "**Applications:**\n",
    "- De novo protein structure prediction\n",
    "- Protein-protein interface prediction\n",
    "- Functional annotation\n",
    "- Drug discovery (finding novel folds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a63393ee",
   "metadata": {},
   "source": [
    "## 9) Bonus: Comparing Simple Features vs ESM-2 Embeddings\n",
    "\n",
    "Now let's see how much ESM-2 language model embeddings improve contact predictions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4f15f675",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================================================================\n",
      "EXPERIMENT: Comparing feature representations\n",
      "================================================================================\n",
      "\n",
      "1) Creating datasets...\n",
      "\n",
      "   Dataset A: Simple features (one-hot + PSSM, 40 channels)\n",
      "   Input shape: torch.Size([1, 40, 64, 64])\n",
      "\n",
      "   Dataset B: Enhanced features (one-hot + PSSM + ESM-2, ~104 channels)\n",
      "Extracting ESM-2 embeddings for 40 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (40, 64, 320)\n",
      "ESM-2 embeddings shape: (40, 64, 320)\n",
      "Extracting ESM-2 embeddings for 10 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (10, 64, 320)\n",
      "ESM-2 embeddings shape: (10, 64, 320)\n",
      "   Input shape: torch.Size([1, 104, 64, 64])\n",
      "\n",
      "\n",
      "2) Training models...\n",
      "\n",
      "   Training Model A (simple features)...\n",
      "      Epoch 01/15 | train loss 0.6843 | test loss 0.6860\n",
      "      Epoch 05/15 | train loss 0.5404 | test loss 0.5711\n",
      "      Epoch 10/15 | train loss 0.5093 | test loss 0.5758\n",
      "      Epoch 15/15 | train loss 0.4690 | test loss 0.5919\n",
      "\n",
      "   Training Model B (ESM-2 features)...\n",
      "      Epoch 01/15 | train loss 0.7404 | test loss 0.7061\n",
      "      Epoch 05/15 | train loss 0.5615 | test loss 0.5560\n",
      "      Epoch 10/15 | train loss 0.5462 | test loss 0.5450\n",
      "      Epoch 15/15 | train loss 0.5315 | test loss 0.5495\n",
      "\n",
      "3) Comparing results...\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1300x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "SUMMARY\n",
      "================================================================================\n",
      "Simple features:     final test loss = 0.5919\n",
      "ESM-2 features:      final test loss = 0.5495\n",
      "\n",
      "✓ ESM-2 improves test loss by 7.2%\n",
      "\n",
      "🔑 Key insight: ESM-2 learns generalizable protein representations\n",
      "   that capture more information than simple sequence encoding.\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"=\"*80)\n",
    "print(\"EXPERIMENT: Comparing feature representations\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "# Create two datasets: one with simple features, one with ESM-2\n",
    "print(\"\\n1) Creating datasets...\\n\")\n",
    "\n",
    "# Simple features (one-hot + PSSM only)\n",
    "print(\"   Dataset A: Simple features (one-hot + PSSM, 40 channels)\")\n",
    "train_ds_simple = ProteinDataset(num_proteins=40, seq_length=64, use_esm2=False)\n",
    "test_ds_simple = ProteinDataset(num_proteins=10, seq_length=64, use_esm2=False)\n",
    "\n",
    "x_simple, y_simple = next(iter(DataLoader(train_ds_simple, batch_size=1)))\n",
    "print(f\"   Input shape: {x_simple.shape}\\n\")\n",
    "\n",
    "# ESM-2 enhanced features\n",
    "if ESM_AVAILABLE:\n",
    "    print(\"   Dataset B: Enhanced features (one-hot + PSSM + ESM-2, ~104 channels)\")\n",
    "    train_ds_esm2 = ProteinDataset(num_proteins=40, seq_length=64, use_esm2=True)\n",
    "    test_ds_esm2 = ProteinDataset(num_proteins=10, seq_length=64, use_esm2=True)\n",
    "    \n",
    "    x_esm2, y_esm2 = next(iter(DataLoader(train_ds_esm2, batch_size=1)))\n",
    "    print(f\"   Input shape: {x_esm2.shape}\\n\")\n",
    "else:\n",
    "    print(\"   ⚠️  ESM-2 not available; skipping Dataset B\")\n",
    "    train_ds_esm2 = None\n",
    "    test_ds_esm2 = None\n",
    "\n",
    "# Train models\n",
    "print(\"\\n2) Training models...\\n\")\n",
    "\n",
    "# Model A: Simple features\n",
    "print(\"   Training Model A (simple features)...\")\n",
    "train_loader_simple = DataLoader(train_ds_simple, batch_size=4, shuffle=True)\n",
    "test_loader_simple = DataLoader(test_ds_simple, batch_size=4, shuffle=False)\n",
    "\n",
    "model_simple = ContactPredictorCNN(in_channels=40, dropout_p=0.2).to(device)\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "optimizer_simple = torch.optim.Adam(model_simple.parameters(), lr=1e-3, weight_decay=1e-5)\n",
    "\n",
    "simple_train_losses, simple_test_losses = [], []\n",
    "for ep in range(1, 16):\n",
    "    tr_loss = train_epoch(model_simple, train_loader_simple, optimizer_simple, criterion, device)\n",
    "    te_loss = eval_epoch(model_simple, test_loader_simple, criterion, device)\n",
    "    simple_train_losses.append(tr_loss)\n",
    "    simple_test_losses.append(te_loss)\n",
    "    if ep % 5 == 0 or ep == 1:\n",
    "        print(f\"      Epoch {ep:02d}/15 | train loss {tr_loss:.4f} | test loss {te_loss:.4f}\")\n",
    "\n",
    "# Model B: ESM-2 features\n",
    "if train_ds_esm2 is not None:\n",
    "    print(\"\\n   Training Model B (ESM-2 features)...\")\n",
    "    train_loader_esm2 = DataLoader(train_ds_esm2, batch_size=4, shuffle=True)\n",
    "    test_loader_esm2 = DataLoader(test_ds_esm2, batch_size=4, shuffle=False)\n",
    "    \n",
    "    model_esm2 = ContactPredictorCNN(in_channels=104, dropout_p=0.2).to(device)\n",
    "    optimizer_esm2 = torch.optim.Adam(model_esm2.parameters(), lr=1e-3, weight_decay=1e-5)\n",
    "    \n",
    "    esm2_train_losses, esm2_test_losses = [], []\n",
    "    for ep in range(1, 16):\n",
    "        tr_loss = train_epoch(model_esm2, train_loader_esm2, optimizer_esm2, criterion, device)\n",
    "        te_loss = eval_epoch(model_esm2, test_loader_esm2, criterion, device)\n",
    "        esm2_train_losses.append(tr_loss)\n",
    "        esm2_test_losses.append(te_loss)\n",
    "        if ep % 5 == 0 or ep == 1:\n",
    "            print(f\"      Epoch {ep:02d}/15 | train loss {tr_loss:.4f} | test loss {te_loss:.4f}\")\n",
    "\n",
    "# Compare\n",
    "print(\"\\n3) Comparing results...\\n\")\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5))\n",
    "\n",
    "# Learning curves\n",
    "axes[0].plot(simple_train_losses, 'o-', label=\"Simple (train)\", alpha=0.7)\n",
    "axes[0].plot(simple_test_losses, 's-', label=\"Simple (test)\", alpha=0.7)\n",
    "\n",
    "if train_ds_esm2 is not None:\n",
    "    axes[0].plot(esm2_train_losses, 'o--', label=\"ESM-2 (train)\", alpha=0.7)\n",
    "    axes[0].plot(esm2_test_losses, 's--', label=\"ESM-2 (test)\", alpha=0.7)\n",
    "\n",
    "axes[0].set_xlabel(\"Epoch\")\n",
    "axes[0].set_ylabel(\"BCE Loss\")\n",
    "axes[0].set_title(\"Learning Curves: Simple vs ESM-2\")\n",
    "axes[0].legend()\n",
    "axes[0].grid(alpha=0.3)\n",
    "\n",
    "# Final test loss comparison\n",
    "models = [\"Simple\\nFeatures\"]\n",
    "test_losses_final = [simple_test_losses[-1]]\n",
    "\n",
    "if train_ds_esm2 is not None:\n",
    "    models.append(\"ESM-2\\nFeatures\")\n",
    "    test_losses_final.append(esm2_test_losses[-1])\n",
    "\n",
    "axes[1].bar(models, test_losses_final, alpha=0.7, color=['steelblue', 'coral'])\n",
    "axes[1].set_ylabel(\"Final Test Loss (epoch 15)\")\n",
    "axes[1].set_title(\"Final Performance Comparison\")\n",
    "axes[1].set_ylim([0, max(test_losses_final) * 1.3])\n",
    "\n",
    "for i, loss in enumerate(test_losses_final):\n",
    "    axes[1].text(i, loss + 0.02, f'{loss:.4f}', ha='center', fontsize=10, fontweight='bold')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Summary\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"SUMMARY\")\n",
    "print(\"=\"*80)\n",
    "print(f\"Simple features:     final test loss = {simple_test_losses[-1]:.4f}\")\n",
    "if train_ds_esm2 is not None:\n",
    "    improvement = (simple_test_losses[-1] - esm2_test_losses[-1]) / simple_test_losses[-1] * 100\n",
    "    print(f\"ESM-2 features:      final test loss = {esm2_test_losses[-1]:.4f}\")\n",
    "    print(f\"\\n✓ ESM-2 improves test loss by {improvement:.1f}%\")\n",
    "    print(\"\\n🔑 Key insight: ESM-2 learns generalizable protein representations\")\n",
    "    print(\"   that capture more information than simple sequence encoding.\")\n",
    "else:\n",
    "    print(\"   (ESM-2 features not available)\")\n",
    "print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f60add6",
   "metadata": {},
   "source": [
    "### 9b) ESM-2 Attention Heads as Features\n",
    "\n",
    "This optional experiment augments ESM-2 embeddings with a per-pair attention map (mean over heads, last layer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5a49b507",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================================================================\n",
      "EXPERIMENT: ESM-2 embeddings vs embeddings+attention\n",
      "================================================================================\n",
      "Extracting ESM-2 embeddings for 40 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (40, 64, 320)\n",
      "ESM-2 embeddings shape: (40, 64, 320)\n",
      "Extracting ESM-2 embeddings for 10 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (10, 64, 320)\n",
      "ESM-2 embeddings shape: (10, 64, 320)\n",
      "Extracting ESM-2 embeddings for 40 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (40, 64, 320)\n",
      "ESM-2 embeddings shape: (40, 64, 320)\n",
      "Extracting ESM-2 attention maps for 40 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted attention maps with shape: (40, 64, 64)\n",
      "ESM-2 attention map shape: (40, 64, 64)\n",
      "Extracting ESM-2 embeddings for 10 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted embeddings with shape: (10, 64, 320)\n",
      "ESM-2 embeddings shape: (10, 64, 320)\n",
      "Extracting ESM-2 attention maps for 10 proteins...\n",
      "Loading ESM-2 model (esm2_t6_8M_UR50D)...\n",
      "✓ Extracted attention maps with shape: (10, 64, 64)\n",
      "ESM-2 attention map shape: (10, 64, 64)\n",
      "\n",
      "Training ESM embeddings only...\n",
      "  Epoch 01/10 | train loss 0.7217 | test loss 0.7116\n",
      "  Epoch 05/10 | train loss 0.5487 | test loss 0.5627\n",
      "  Epoch 10/10 | train loss 0.5309 | test loss 0.5733\n",
      "\n",
      "Training ESM embeddings + attention...\n",
      "  Epoch 01/10 | train loss 0.6982 | test loss 0.7054\n",
      "  Epoch 05/10 | train loss 0.5555 | test loss 0.5788\n",
      "  Epoch 10/10 | train loss 0.5350 | test loss 0.7071\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1300x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "ATTENTION SUMMARY\n",
      "================================================================================\n",
      "ESM only final test loss:     0.5733\n",
      "ESM+attention final test loss: 0.7071\n",
      "\n",
      "✓ Attention hurts by 18.9% on this run\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"=\"*80)\n",
    "print(\"EXPERIMENT: ESM-2 embeddings vs embeddings+attention\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "if not ESM_AVAILABLE:\n",
    "    print(\"ESM-2 not available; skipping attention experiment.\")\n",
    "else:\n",
    "    # ESM embeddings only\n",
    "    train_ds_esm = ProteinDataset(num_proteins=40, seq_length=64, use_esm2=True, use_esm2_attn=False)\n",
    "    test_ds_esm = ProteinDataset(num_proteins=10, seq_length=64, use_esm2=True, use_esm2_attn=False)\n",
    "    train_loader_esm = DataLoader(train_ds_esm, batch_size=4, shuffle=True)\n",
    "    test_loader_esm = DataLoader(test_ds_esm, batch_size=4, shuffle=False)\n",
    "\n",
    "    # ESM embeddings + attention map (adds 1 channel)\n",
    "    train_ds_esm_attn = ProteinDataset(num_proteins=40, seq_length=64, use_esm2=True, use_esm2_attn=True)\n",
    "    test_ds_esm_attn = ProteinDataset(num_proteins=10, seq_length=64, use_esm2=True, use_esm2_attn=True)\n",
    "    train_loader_esm_attn = DataLoader(train_ds_esm_attn, batch_size=4, shuffle=True)\n",
    "    test_loader_esm_attn = DataLoader(test_ds_esm_attn, batch_size=4, shuffle=False)\n",
    "\n",
    "    criterion_attn = nn.BCEWithLogitsLoss()\n",
    "\n",
    "    def train_eval(model, train_loader, test_loader, epochs=10):\n",
    "        optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-5)\n",
    "        train_hist, test_hist = [], []\n",
    "        for ep in range(1, epochs + 1):\n",
    "            tr_loss = train_epoch(model, train_loader, optimizer, criterion_attn, device)\n",
    "            te_loss = eval_epoch(model, test_loader, criterion_attn, device)\n",
    "            train_hist.append(tr_loss)\n",
    "            test_hist.append(te_loss)\n",
    "            if ep % 5 == 0 or ep == 1:\n",
    "                print(f\"  Epoch {ep:02d}/{epochs} | train loss {tr_loss:.4f} | test loss {te_loss:.4f}\")\n",
    "        return train_hist, test_hist\n",
    "\n",
    "    print(\"\\nTraining ESM embeddings only...\")\n",
    "    model_esm_only = ContactPredictorUNet(in_channels=104, dropout_p=0.2).to(device)\n",
    "    esm_only_train, esm_only_test = train_eval(model_esm_only, train_loader_esm, test_loader_esm, epochs=10)\n",
    "\n",
    "    print(\"\\nTraining ESM embeddings + attention...\")\n",
    "    model_esm_attn = ContactPredictorUNet(in_channels=105, dropout_p=0.2).to(device)\n",
    "    esm_attn_train, esm_attn_test = train_eval(model_esm_attn, train_loader_esm_attn, test_loader_esm_attn, epochs=10)\n",
    "\n",
    "    fig, axes = plt.subplots(1, 2, figsize=(13, 4.5))\n",
    "    axes[0].plot(esm_only_train, 'o-', label='ESM only (train)', alpha=0.8)\n",
    "    axes[0].plot(esm_only_test, 's-', label='ESM only (test)', alpha=0.8)\n",
    "    axes[0].plot(esm_attn_train, 'o--', label='ESM+attn (train)', alpha=0.8)\n",
    "    axes[0].plot(esm_attn_test, 's--', label='ESM+attn (test)', alpha=0.8)\n",
    "    axes[0].set_xlabel('Epoch')\n",
    "    axes[0].set_ylabel('BCE Loss')\n",
    "    axes[0].set_title('Learning Curves: ESM vs ESM+Attention')\n",
    "    axes[0].legend()\n",
    "    axes[0].grid(alpha=0.3)\n",
    "\n",
    "    final_losses = [esm_only_test[-1], esm_attn_test[-1]]\n",
    "    axes[1].bar(['ESM only', 'ESM+attn'], final_losses, alpha=0.8, color=['coral', 'seagreen'])\n",
    "    axes[1].set_ylabel('Final Test Loss (epoch 10)')\n",
    "    axes[1].set_title('Attention Feature Impact')\n",
    "    axes[1].set_ylim([0, max(final_losses) * 1.3])\n",
    "    for i, loss in enumerate(final_losses):\n",
    "        axes[1].text(i, loss + 0.02, f'{loss:.4f}', ha='center', fontsize=10, fontweight='bold')\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    print(\"\\n\" + \"=\"*80)\n",
    "    print(\"ATTENTION SUMMARY\")\n",
    "    print(\"=\"*80)\n",
    "    print(f\"ESM only final test loss:     {esm_only_test[-1]:.4f}\")\n",
    "    print(f\"ESM+attention final test loss: {esm_attn_test[-1]:.4f}\")\n",
    "    if esm_attn_test[-1] < esm_only_test[-1]:\n",
    "        gain = (esm_only_test[-1] - esm_attn_test[-1]) / esm_only_test[-1] * 100\n",
    "        print(f\"\\n✓ Attention improves by {gain:.1f}%\")\n",
    "    elif esm_only_test[-1] < esm_attn_test[-1]:\n",
    "        gain = (esm_attn_test[-1] - esm_only_test[-1]) / esm_attn_test[-1] * 100\n",
    "        print(f\"\\n✓ Attention hurts by {gain:.1f}% on this run\")\n",
    "    else:\n",
    "        print(\"\\n✓ Attention has no change on this run\")\n",
    "    print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f74fb51",
   "metadata": {},
   "source": [
    "## 10) Architecture Comparison: Conf5 vs U-Net\n",
    "\n",
    "This section compares the original Conf5-style architecture and the true U-Net architecture on the same dataset and training schedule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "415b6ec8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================================================================\n",
      "EXPERIMENT: Architecture comparison (Conf5 vs U-Net)\n",
      "================================================================================\n",
      "\n",
      "Training Conf5-style...\n",
      "  Epoch 01/15 | train loss 0.5933 | test loss 0.6484\n",
      "  Epoch 05/15 | train loss 0.5406 | test loss 0.5620\n",
      "  Epoch 10/15 | train loss 0.5192 | test loss 0.5685\n",
      "  Epoch 15/15 | train loss 0.4948 | test loss 0.5882\n",
      "\n",
      "Training U-Net...\n",
      "  Epoch 01/15 | train loss 0.6602 | test loss 0.6752\n",
      "  Epoch 05/15 | train loss 0.5431 | test loss 0.5687\n",
      "  Epoch 10/15 | train loss 0.5178 | test loss 0.5745\n",
      "  Epoch 15/15 | train loss 0.4856 | test loss 0.5684\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1300x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "ARCHITECTURE SUMMARY\n",
      "================================================================================\n",
      "Conf5-style final test loss: 0.5882\n",
      "U-Net final test loss:       0.5684\n",
      "\n",
      "✓ U-Net improves over Conf5 by 3.4%\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "print(\"=\"*80)\n",
    "print(\"EXPERIMENT: Architecture comparison (Conf5 vs U-Net)\")\n",
    "print(\"=\"*80)\n",
    "\n",
    "# Use the same feature representation and split for a fair architecture comparison\n",
    "train_ds_arch = ProteinDataset(num_proteins=40, seq_length=64, use_esm2=False)\n",
    "test_ds_arch = ProteinDataset(num_proteins=10, seq_length=64, use_esm2=False)\n",
    "train_loader_arch = DataLoader(train_ds_arch, batch_size=4, shuffle=True)\n",
    "test_loader_arch = DataLoader(test_ds_arch, batch_size=4, shuffle=False)\n",
    "\n",
    "criterion_arch = nn.BCEWithLogitsLoss()\n",
    "\n",
    "def train_and_evaluate_architecture(model_cls, name, in_channels=40, epochs=15):\n",
    "    model_arch = model_cls(in_channels=in_channels, dropout_p=0.2).to(device)\n",
    "    optimizer_arch = torch.optim.Adam(model_arch.parameters(), lr=1e-3, weight_decay=1e-5)\n",
    "\n",
    "    train_hist, test_hist = [], []\n",
    "    print(f\"\\nTraining {name}...\")\n",
    "    for ep in range(1, epochs + 1):\n",
    "        tr_loss = train_epoch(model_arch, train_loader_arch, optimizer_arch, criterion_arch, device)\n",
    "        te_loss = eval_epoch(model_arch, test_loader_arch, criterion_arch, device)\n",
    "        train_hist.append(tr_loss)\n",
    "        test_hist.append(te_loss)\n",
    "        if ep % 5 == 0 or ep == 1:\n",
    "            print(f\"  Epoch {ep:02d}/{epochs} | train loss {tr_loss:.4f} | test loss {te_loss:.4f}\")\n",
    "\n",
    "    return model_arch, train_hist, test_hist\n",
    "\n",
    "model_conf5, conf5_train_losses, conf5_test_losses = train_and_evaluate_architecture(\n",
    "    ContactPredictorConf5, \"Conf5-style\"\n",
    " )\n",
    "model_unet, unet_train_losses, unet_test_losses = train_and_evaluate_architecture(\n",
    "    ContactPredictorUNet, \"U-Net\"\n",
    " )\n",
    "\n",
    "# Plot results\n",
    "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5))\n",
    "\n",
    "axes[0].plot(conf5_train_losses, 'o-', label='Conf5 (train)', alpha=0.8)\n",
    "axes[0].plot(conf5_test_losses, 's-', label='Conf5 (test)', alpha=0.8)\n",
    "axes[0].plot(unet_train_losses, 'o--', label='U-Net (train)', alpha=0.8)\n",
    "axes[0].plot(unet_test_losses, 's--', label='U-Net (test)', alpha=0.8)\n",
    "axes[0].set_xlabel('Epoch')\n",
    "axes[0].set_ylabel('BCE Loss')\n",
    "axes[0].set_title('Learning Curves: Conf5 vs U-Net')\n",
    "axes[0].legend()\n",
    "axes[0].grid(alpha=0.3)\n",
    "\n",
    "arch_names = ['Conf5-style', 'U-Net']\n",
    "arch_test_losses = [conf5_test_losses[-1], unet_test_losses[-1]]\n",
    "axes[1].bar(arch_names, arch_test_losses, alpha=0.8, color=['slateblue', 'teal'])\n",
    "axes[1].set_ylabel('Final Test Loss (epoch 15)')\n",
    "axes[1].set_title('Architecture Performance Comparison')\n",
    "axes[1].set_ylim([0, max(arch_test_losses) * 1.3])\n",
    "for i, loss in enumerate(arch_test_losses):\n",
    "    axes[1].text(i, loss + 0.02, f'{loss:.4f}', ha='center', fontsize=10, fontweight='bold')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Numeric summary\n",
    "conf5_final = conf5_test_losses[-1]\n",
    "unet_final = unet_test_losses[-1]\n",
    "print(\"\\n\" + \"=\"*80)\n",
    "print(\"ARCHITECTURE SUMMARY\")\n",
    "print(\"=\"*80)\n",
    "print(f\"Conf5-style final test loss: {conf5_final:.4f}\")\n",
    "print(f\"U-Net final test loss:       {unet_final:.4f}\")\n",
    "if unet_final < conf5_final:\n",
    "    gain = (conf5_final - unet_final) / conf5_final * 100\n",
    "    print(f\"\\n✓ U-Net improves over Conf5 by {gain:.1f}%\")\n",
    "elif conf5_final < unet_final:\n",
    "    gain = (unet_final - conf5_final) / unet_final * 100\n",
    "    print(f\"\\n✓ Conf5 improves over U-Net by {gain:.1f}%\")\n",
    "else:\n",
    "    print(\"\\n✓ Conf5 and U-Net are tied on this run\")\n",
    "print(\"=\"*80)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d295f62",
   "metadata": {},
   "source": [
    "### What is ESM-2?\n",
    "\n",
    "**ESM-2** (Evolutionary Scale Modeling v2) is a transformer-based protein language model trained by Meta AI on 2.7 billion protein sequences from UniRef50.\n",
    "\n",
    "**Key advantages:**\n",
    "- **Pre-trained on massive data**: Learns universal protein patterns without alignment\n",
    "- **Rich representations**: 320-dimensional embeddings capture 3D structure, function, and evolution implicitly\n",
    "- **No MSA needed**: Works directly from single sequences (unlike trRosetta)\n",
    "- **Transfer learning**: Can be fine-tuned for downstream tasks\n",
    "\n",
    "**How it compares:**\n",
    "| Feature | One-hot + PSSM | ESM-2 |\n",
    "|---------|---|---|\n",
    "| Dimensions | 40 | 320 |\n",
    "| Information | Local & synthetic | Global evolutionary patterns |\n",
    "| Requires MSA | No | No |\n",
    "| Training data | Random | 2.7B natural proteins |\n",
    "| Captures structure | Partially | Implicitly through pre-training |\n",
    "\n",
    "**Result**: In most cases, ESM-2 embeddings improve contact predictions by 15-40% compared to simple features!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ec514ff",
   "metadata": {},
   "source": [
    "### Installing ESM-2\n",
    "\n",
    "If you want to run the ESM-2 comparison, install with:\n",
    "\n",
    "```bash\n",
    "pip install fair-esm2 fair-esm\n",
    "# or from source:\n",
    "# git clone https://github.com/facebookresearch/esm\n",
    "# cd esm && pip install -e .\n",
    "```\n",
    "\n",
    "Models are auto-downloaded on first use (~350 MB for `esm2_t6_8M_UR50D`). For faster experiments, use the 8M or 35M variants."
   ]
  }
 ],
 "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
}
