FaFc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0ed1a96a-fb16-4260-a45b-2a08c074749a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bhui/miniconda3/envs/xy_py38/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from models import *\n",
    "import torchvision\n",
    "from torchvision import transforms, datasets\n",
    "from torch.distributions import normal\n",
    "import matplotlib.pyplot as plt\n",
    "import captum\n",
    "from captum.attr import DeepLift, IntegratedGradients, Saliency, NoiseTunnel, GradientShap\n",
    "from captum.attr import visualization as viz\n",
    "import argparse\n",
    "from utils import get_args\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "07fd2374-74c6-46ff-afbb-5595735c1d46",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.set_device(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "47830af4-7473-4cb5-b959-72b2ee274744",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_gaussian_noise(noise_scale, input):\n",
    "    noise = torch.randn_like(input) * noise_scale\n",
    "    return input + noise\n",
    "\n",
    "def predict_with_randomized_smoothing(noise_scale, model, image, num_samples):\n",
    "    # Expand the single image to a batch\n",
    "    image_batch = image.repeat(num_samples, 1, 1, 1)\n",
    "    # Add Gaussian noise\n",
    "    noisy_images = add_gaussian_noise(noise_scale, image_batch)\n",
    "\n",
    "    # Predict using the model\n",
    "    predictions, reconstruction ,primary_caps_output, digit_caps_output, c, b = model(noisy_images)\n",
    "\n",
    "    # Get the predicted classes for each noisy image\n",
    "    _, predicted_classes = predictions.max(1)\n",
    "    #Result\n",
    "    avg_noisy_image = noisy_images.mean(0, keepdim=True)\n",
    "    prediction = torch.bincount(predicted_classes).argmax().item()\n",
    "    # Return the most frequently predicted class\n",
    "    return avg_noisy_image, predictions, predicted_classes, prediction\n",
    "\n",
    "def show_image(input, noise_scale):\n",
    "    fig, axes = plt.subplots(1, len(noise_scale), figsize=(20, 10))\n",
    "    if not isinstance(axes, (list, np.ndarray)):\n",
    "        axes = [axes]\n",
    "    for idx, noise in enumerate(noise_scale):\n",
    "        avg_noisy_image, predictions, predicted_classes, prediction= predict_with_randomized_smoothing(noise, global_model, input, 100)\n",
    "        print(f'Noise: {noise}, Ground Truth: {ground_truth_prediction}, Noised Result: {prediction}')\n",
    "        img = avg_noisy_image.squeeze().cpu().detach().numpy()\n",
    "        img = (img - img.min()) / (img.max() - img.min())\n",
    "        ax = axes[idx]\n",
    "        ax.imshow(img, cmap='gray')\n",
    "        ax.axis('off')\n",
    "        ax.set_title(f'noise_scale:{noise}')\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "aa4ac1b3-7aaa-4f47-bae0-7fa53555ec4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def squash(x, dim=-1):\n",
    "    suqared_norm = (x ** 2 ).sum(dim=dim, keepdim=True)\n",
    "    scale = suqared_norm / (1 + suqared_norm)\n",
    "    return scale * (x / suqared_norm.sqrt() + 1e-8)\n",
    "\n",
    "\n",
    "# class PrimaryCaps(nn.Module):\n",
    "#     def __init__(self, num_conv_units, in_channels, out_channels, kernel_size, stride):  \n",
    "#         super(PrimaryCaps, self).__init__()\n",
    "#         self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels * num_conv_units,\n",
    "#                               kernel_size=kernel_size, stride=stride)\n",
    "        \n",
    "#         self.out_channels = out_channels\n",
    "\n",
    "#     def forward(self, x):\n",
    "#         out = self.conv(x) \n",
    "#         batch_size = out.shape[0] \n",
    "#         return squash(out.contiguous().view(batch_size, -1, self.out_channels), dim=-1) \n",
    "# Input: [Batch_Size, 256, 20, 20] Output: [Batch_Size, 1152, 8]\n",
    "class PrimaryCaps(nn.Module):\n",
    "    def __init__(self, num_conv_units, in_channels, out_channels, kernel_size, stride):\n",
    "        super(PrimaryCaps, self).__init__()\n",
    "        self.num_conv_units = num_conv_units\n",
    "        input_features = 20 * 20 * in_channels \n",
    "        output_features = 6 * 6 * out_channels * num_conv_units  \n",
    "        self.fc = nn.Linear(input_features, output_features)\n",
    "        self.out_channels = out_channels\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.shape[0]\n",
    "        x = x.view(batch_size, -1) \n",
    "        out = self.fc(x)\n",
    "        out = out.view(batch_size, 6 * 6 * self.num_conv_units, -1)\n",
    "        return squash(out, dim=-1)\n",
    "\n",
    "\n",
    "\n",
    "class DigitCaps(nn.Module):\n",
    "    def __init__(self, in_dim, in_caps, num_caps, dim_caps, num_routing, device):\n",
    "        super(DigitCaps, self).__init__()\n",
    "        self.in_dim = in_dim\n",
    "        self.in_caps = in_caps\n",
    "        self.num_caps = num_caps\n",
    "        self.dim_caps = dim_caps\n",
    "        self.num_routing = num_routing\n",
    "        self.device = device\n",
    "        self.W = nn.Parameter(0.01 * torch.randn(1, num_caps, in_caps, dim_caps, in_dim),\n",
    "                              requires_grad=True)\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        x = x.unsqueeze(1).unsqueeze(4)\n",
    "        u_hat = torch.matmul(self.W, x)\n",
    "        u_hat = u_hat.squeeze(-1)\n",
    "        temp_u_hat = u_hat.detach()\n",
    "        b = torch.zeros(batch_size, self.num_caps, self.in_caps, 1).to(self.device)\n",
    "        for route_iter in range(self.num_routing - 1):\n",
    "            c = b.softmax(dim=1)\n",
    "            s = (c * temp_u_hat).sum(dim=2)\n",
    "            v = squash(s)\n",
    "            uv = torch.matmul(temp_u_hat, v.unsqueeze(-1))\n",
    "            b += uv\n",
    "        c = b.softmax(dim=1)\n",
    "        s = (c * u_hat).sum(dim=2)\n",
    "        v = squash(s)\n",
    "\n",
    "        return v, c, b\n",
    "\n",
    "class CapsNet(nn.Module):\n",
    "    def __init__(self, device):\n",
    "        super(CapsNet, self).__init__()\n",
    "        self.device = device\n",
    "        self.conv = nn.Conv2d(1, 256, 9) # 28 * 28 → 20 * 20\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.primary_caps = PrimaryCaps(num_conv_units=32,       \n",
    "                                        in_channels=256,\n",
    "                                        out_channels=8,\n",
    "                                        kernel_size=9,\n",
    "                                        stride=2)            \n",
    "        self.digit_caps = DigitCaps(in_dim=8,\n",
    "                                    in_caps=32 * 6 * 6,\n",
    "                                    num_caps=10,\n",
    "                                    dim_caps=16,\n",
    "                                    num_routing=3,\n",
    "                                    device=device)  \n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.Linear(16 * 10, 512),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(512, 1024),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(1024, 784),\n",
    "            nn.Sigmoid())\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.relu(self.conv(x)) \n",
    "        out = self.primary_caps(out) \n",
    "        primary_caps_output = out\n",
    "        out, c, b = self.digit_caps(primary_caps_output)\n",
    "        digit_caps_output = out\n",
    "        logits = torch.norm(digit_caps_output, dim=-1)\n",
    "        pred = torch.eye(10).to(self.device).index_select(dim=0, index=torch.argmax(logits, dim=1))\n",
    "        batch_size = out.shape[0]\n",
    "        reconstruction = self.decoder((out * pred.unsqueeze(2)).contiguous().view(batch_size, -1))\n",
    "        return logits, reconstruction, primary_caps_output, digit_caps_output, c, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "822def21-dede-481d-aae9-38be484132f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noise: 0, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 0.5, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 1, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 1.5, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 2.0, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 2.5, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 3.0, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 3.5, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 4.0, Ground Truth: 6, Noised Result: 6\n",
      "Noise: 4.5, Ground Truth: 6, Noised Result: 8\n",
      "Noise: 5.0, Ground Truth: 6, Noised Result: 8\n"
     ]
    }
   ],
   "source": [
    "args = get_args.get_arg()\n",
    "data_dir = './data/fashion'\n",
    "sigma = 0.5\n",
    "apply_transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n",
    "train_dataset = datasets.FashionMNIST(data_dir, train=True, download=True, transform=apply_transform)\n",
    "test_dataset = datasets.FashionMNIST(data_dir, train=False, download=True, transform=apply_transform)\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=128,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "device = 'cuda'\n",
    "global_model = CapsNet(device=device)\n",
    "global_model.load_state_dict(torch.load(f'./checkpoints/Capsule/fashion/common/best_model_fashion.pth'))\n",
    "global_model.to(device)\n",
    "dataiter = iter(test_loader)\n",
    "images, labels = next(dataiter)\n",
    "images, labels = images.to(device), labels.to(device)\n",
    "classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress',\n",
    "           'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot')\n",
    "ind = 4\n",
    "input = images[ind].unsqueeze(0)\n",
    "input.requires_grad = True\n",
    "global_model.eval()\n",
    "ground_truth_predictions, reconstruction, primary_caps_output, digit_caps_output, c, b= global_model(input)\n",
    "_, predicted_classes = ground_truth_predictions.max(1)\n",
    "ground_truth_prediction = torch.bincount(predicted_classes).argmax().item()\n",
    "noise_scale = [0, 0.5, 1, 1.5, 2.0, 2.5, 3.0 ,3.5, 4.0, 4.5, 5.0]\n",
    "show_image(input, noise_scale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d71443f1-3e5c-4058-9faa-16e6598a3054",
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_logits_only(input_data):\n",
    "    return global_model(input_data)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c9ee635d-b1ce-470a-80d7-eb62878064a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------\n",
      "Original Image\n",
      "Predicted: Shirt  Probability: 0.1919926106929779\n"
     ]
    }
   ],
   "source": [
    "saliency = Saliency(forward_logits_only)\n",
    "ig = IntegratedGradients(forward_logits_only)\n",
    "dl = DeepLift(forward_logits_only)\n",
    "nt = NoiseTunnel(ig)\n",
    "print('-------------------')\n",
    "print('Original Image')\n",
    "print('Predicted:', classes[predicted_classes],\n",
    "      ' Probability:', torch.max(F.softmax(ground_truth_predictions, 1)).item())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bc371740-ba69-430b-a64b-cad384ca9123",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualization(noise_scale, model, input):\n",
    "    avg_noisy_image, predictions, predicted_classes, prediction= predict_with_randomized_smoothing(noise_scale, model, input, 100)\n",
    "    global_model.zero_grad()\n",
    "    tensor_attributions = ig.attribute(input, \n",
    "                                   target=labels[ind], \n",
    "                                   baselines=avg_noisy_image * 0, \n",
    "                                   n_steps=1000, \n",
    "                                   return_convergence_delta=True)\n",
    "    attr_ig, delta = tensor_attributions\n",
    "    tensor_28x28 = attr_ig.squeeze().cpu().detach().reshape(28, 28)\n",
    "    attr_ig = np.transpose(tensor_28x28.detach().numpy(), (1, 0))\n",
    "    print('-------------------')\n",
    "    print('Smoothing Image')\n",
    "    print('Predicted:', classes[prediction], ' Probability:', torch.max(F.softmax(predictions, 1)).item())\n",
    "    attr_ig = attr_ig[:, :, np.newaxis]\n",
    "    avg_noisy_np = avg_noisy_image.squeeze().unsqueeze(-1).cpu().detach().numpy()\n",
    "    _, axis = viz.visualize_image_attr(attr_ig, avg_noisy_np, method=\"masked_image\", sign=\"positive\",\n",
    "                              show_colorbar=True, title=\"Overlayed Integrated Gradients\", use_pyplot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "215415b3-3586-47fc-927d-9121ad905f60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------\n",
      "Smoothing Image\n",
      "Predicted: Shirt  Probability: 0.19220227003097534\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAAH4CAYAAADZ+e2OAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAiBElEQVR4nO3dZ3SUZf7/8c8kpJFOyZIETJNV6VJkRUJA0EhxZTkaQKUq4sGy6KLr/iw0BREFVjCIyAIiRzkioO6qiAio6CKuCmI7gMRGr8Zg0CTX/4H/jIxJIMwEB/i+X+fwIDP3NfeVO0Pec0/J5XHOOQEAYFRIsCcAAEAwEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQlRq3rx58ng8KigoCPZUqjR48GClp6cHexpmjBkzRh6PJ9jTOGHp6ekaPHiw9+vVq1fL4/Fo9erVQZsTTi2EMMg++eQTXXvttUpNTVVERIRSUlJ0zTXX6JNPPgn21M4YnTt3VrNmzfwa+84772jMmDE6ePBgzU7qJNm+fbvGjBmjjz76KNhT0VtvvaW8vDylpqYqPDxc8fHxat++vcaNG6ddu3YFe3on3YQJE7Rs2bJgTwPVQAiDaMmSJWrdurVWrlypIUOGKD8/X9ddd51WrVql1q1ba+nSpcGeonnvvPOOxo4de1qFcOzYsUEP4X333adOnTrpf//7nwYPHqyZM2dqwoQJatq0qR555BF16NAhaHPr1KmTfvzxR3Xq1Omk7ocQnj5qBXsCVm3dulUDBgxQZmam3nzzTdWvX9973V//+ldlZ2drwIAB2rhxozIzM3+3eRUVFSk6Ovp32x+Orbi4WOHh4QoJOX0esy5atEjjx49XXl6eFixYoPDwcJ/rp06dqqlTpx7zNpxzKi4uVlRUVI3PLyQkRJGRkTV+uzh9nT7/u84wkydP1uHDh/XEE0/4RFCS6tWrp1mzZqmoqEgPPfSQJGnx4sXyeDxas2ZNhduaNWuWPB6PNm3a5L3s888/15VXXqk6deooMjJSbdu21Ysvvugzrvx1wDVr1mjEiBFKSkpSw4YNq5zzCy+8oJ49eyolJUURERHKysrS+PHjVVpa6t1m9OjRCgsL0549eyqMv+GGG5SQkKDi4mLvZa+88oqys7MVHR2t2NhY9ezZs9KnhZctW6ZmzZopMjJSzZo1C/hs2ePx6Oabb/bebkREhJo2bapXX33Vu82YMWN0xx13SJIyMjLk8XgqvG769NNPq02bNoqKilKdOnXUr18/ffPNNxX299hjjykzM1NRUVG64IIL9NZbb6lz587q3Lmzd5vy166effZZ3XPPPUpNTVXt2rX1/fffa//+/Ro1apSaN2+umJgYxcXFqXv37tqwYYPP+Hbt2kmShgwZ4p3vvHnzvNusW7dOl112meLj41W7dm3l5ORo7dq1Feb79ttvq127doqMjFRWVpZmzZpV7WN73333qV69epozZ06FCEpSfHy8xowZ43NZenq6evXqpeXLl6tt27aKiory7nPu3Lm6+OKLlZSUpIiICDVp0kQzZ86scLvOOd1///1q2LChateurS5dulR6X6rqNcLqHJvy10m3bNmiwYMHKyEhQfHx8RoyZIgOHz7s3c7j8aioqEjz58/3/hzKX6csLCzUyJEjlZ6eroiICCUlJemSSy7RBx98UJ3Di5PBIShSUlJcenr6MbdJT093DRs2dM45d/jwYRcTE+NGjBhRYbsuXbq4pk2ber/etGmTi4+Pd02aNHGTJk1yM2bMcJ06dXIej8ctWbLEu93cuXOdJNekSROXk5Pjpk+f7h588EGf67Zt2+bdvnfv3i4vL89NnjzZzZw501111VVOkhs1apR3m82bNztJbvr06T5zPHLkiEtMTHRDhw71XvbUU085j8fjLrvsMjd9+nQ3adIkl56e7hISEnz2u3z5chcSEuKaNWvmpkyZ4u6++24XHx/vmjZt6tLS0o55DJ1zLicnx+f4OOecJNeyZUuXnJzsxo8f76ZNm+YyMzNd7dq13d69e51zzm3YsMH179/fSXJTp051CxYscAsWLHA//PCDc865+++/33k8Hte3b1+Xn5/vxo4d6+rVq+fS09PdgQMHvPvKz893klx2drZ79NFH3e233+7q1KnjsrKyXE5Ojne7VatWeX8erVq1clOmTHETJ050RUVFbv369S4rK8vdddddbtasWW7cuHEuNTXVxcfHu++++84559zOnTvduHHjnCR3ww03eOe7detW55xzK1eudOHh4e7CCy90jzzyiJs6dapr0aKFCw8Pd+vWrfPOY+PGjS4qKsqdddZZbuLEiW78+PHuD3/4g2vRooU73q+ML774wkly119//XF/LkdLS0tzZ599tktMTHR33XWXe/zxx92qVaucc861a9fODR482E2dOtVNnz7dXXrppU6SmzFjhs9t3HPPPU6S69Gjh5sxY4YbOnSoS0lJcfXq1XODBg2qcJzLb/9Ejs3o0aOdJHf++ee7Pn36uPz8fHf99dc7Se7OO+/0brdgwQIXERHhsrOzvT+Hd955xznn3NVXX+3Cw8Pd7bff7p588kk3adIkd/nll7unn376hI4Zag4hDIKDBw86Se6KK6445nZ//vOfnST3/fffO+ec69+/v0tKSnIlJSXebXbs2OFCQkLcuHHjvJd17drVNW/e3BUXF3svKysrcx06dHCNGzf2XlYeu44dO/rc5tHXHR2kw4cPV5jj8OHDXe3atX32deGFF7r27dv7bLdkyRKfXz6FhYUuISHBDRs2zGe7nTt3uvj4eJ/LW7Vq5ZKTk93Bgwe9l7322mtOUkAhDA8Pd1u2bPFetmHDhgoRnzx5coXj4JxzBQUFLjQ01D3wwAM+l3/88ceuVq1a3suPHDni6tat69q1a+d+/vln73bz5s1zkioNYWZmZoVjXVxc7EpLS30u27Ztm4uIiPD52a9fv95JcnPnzvXZtqyszDVu3Njl5ua6srIy7+WHDx92GRkZ7pJLLvFe1rt3bxcZGem++uor72WffvqpCw0NPW4IX3jhBSfJTZs2rcL+9+zZ4/Pv6OORlpbmJLlXX321wm1Wdr/Lzc11mZmZ3q93797twsPDXc+ePX2+v//7v/9zko4ZwhM5NuUhPPoBnXPO/eUvf3F169b1uSw6Otpnv+Xi4+PdTTfdVOFyBA9PjQZBYWGhJCk2NvaY25Vf//3330uS+vbtq927d/s8pbN48WKVlZWpb9++kqT9+/frjTfeUF5engoLC7V3717t3btX+/btU25urjZv3qzvvvvOZz/Dhg1TaGjoced99Os15bednZ2tw4cP6/PPP/deN3DgQK1bt05bt271XrZw4UI1atRIOTk5kqQVK1bo4MGD6t+/v3eOe/fuVWhoqNq3b69Vq1ZJknbs2KGPPvpIgwYNUnx8vPf2LrnkEjVp0uS4cz6Wbt26KSsry/t1ixYtFBcXpy+//PK4Y5csWaKysjLl5eX5zL9BgwZq3Lixd/7vv/++9u3bp2HDhqlWrV9fkr/mmmuUmJhY6W0PGjSowmtjERER3tcJS0tLtW/fPsXExOicc86p1lNqH330kTZv3qyrr75a+/bt8863qKhIXbt21ZtvvqmysjKVlpZq+fLl6t27t8466yzv+PPOO0+5ubnH3U/5fTUmJsbn8kOHDql+/fo+/377hp6MjIxK93H0sTh06JD27t2rnJwcffnllzp06JAk6fXXX9dPP/2kW265xecjHiNHjqyxY3O0G2+80efr7Oxs7du3z/v9H0tCQoLWrVun7du3H3db/D54s0wQlAeuPIhV+W0wy1+/WLRokbp27SrplzcmtGrVSn/84x8lSVu2bJFzTvfee6/uvffeSm939+7dSk1N9X6dkZFRrXl/8sknuueee/TGG29U+A9f/gtJ+iXYI0eO1MKFC3Xffffp0KFD+ve//63bbrvN+0tq8+bNkqSLL7640n3FxcVJkr766itJUuPGjStsU90IVOXoX/TlEhMTdeDAgeOO3bx5s5xzlc5LksLCwiT9Ov+zzz7b5/patWpV+RnIyn4eZWVl+uc//6n8/Hxt27bN53XZunXrVmu+0i+RrcqhQ4d05MgR/fjjj1Ue75dffvmY+ym/r/7www8+l8fExGjFihWSpNdee02TJ0+uMLaq++HatWs1evRovfvuuz6vw5XPOT4+vsr7Sf369at8wFGuusfm6Nv57X2n/LoDBw5477tVeeihhzRo0CA1atRIbdq0UY8ePTRw4MDf9U1x8EUIgyA+Pl7JycnauHHjMbfbuHGjUlNTvf+xIiIi1Lt3by1dulT5+fnatWuX1q5dqwkTJnjHlD9yHTVqVJWP4H/7S7k678w7ePCgcnJyFBcXp3HjxikrK0uRkZH64IMP9Pe//93nEXNiYqJ69erlDeHixYt15MgRXXvttRXmuWDBAjVo0KDC/o4+ezpZqjoLds4dd2xZWZk8Ho9eeeWVSm/nt2dEJ6Kyn8eECRN07733aujQoRo/frzq1KmjkJAQjRw5ssLZSlXzlX55k1arVq0q3SYmJkZHjhzxe96SdO6550qSzxu3pF9+nt26dZMkffvtt5WOrez73rp1q7p27apzzz1XU6ZMUaNGjRQeHq6XX35ZU6dOrdb3fjzVPTZHC+S+k5eXp+zsbC1dutT7oGDSpElasmSJunfvfmKTR40ghEHSq1cvzZ49W2+//bY6duxY4fq33npLBQUFGj58uM/lffv21fz587Vy5Up99tlncs55nxaV5H1UGRYW5v3FUxNWr16tffv2acmSJT6fv9q2bVul2w8cOFBXXHGF1q9fr4ULF+r8889X06ZNvdeXPyWZlJR0zHmmpaVJ+vVR+9G++OILv76XE1HVX1LJysqSc04ZGRnes/HKlM9/y5Yt6tKli/fykpISFRQUqEWLFtWax+LFi9WlSxfNmTPH5/KDBw+qXr161Zqv9MuZ9rGOd/369RUVFeX38T7nnHPUuHFjLVu2TNOmTQv4ozgvvfSSjhw5ohdffNHnLKz8qedyR99Pjj6z2rNnz3HP8Kt7bE7Usf4KT3JyskaMGKERI0Zo9+7dat26tR544AFCGCS8Rhgkd9xxh6KiojR8+HDt27fP57r9+/frxhtvVO3atb1v3y/XrVs31alTR4sWLdKiRYt0wQUX+DyllJSUpM6dO2vWrFnasWNHhf1W9rGG6ih/BHz0I96ffvpJ+fn5lW7fvXt31atXT5MmTdKaNWt8zgYlKTc3V3FxcZowYYJ+/vnnKueZnJysVq1aaf78+T5Pv65YsUKffvqpX9/LiSj/Rf7bD9T36dNHoaGhGjt2bIWzAOec92fatm1b1a1bV7Nnz1ZJSYl3m4ULF1brKdhyoaGhFfbz3HPPVXi9t6r5tmnTRllZWXr44YcrPG0p/Xq8Q0NDlZubq2XLlunrr7/2Xv/ZZ59p+fLl1ZrrmDFjtHfvXg0bNqzSn211zprKVXa/O3TokObOneuzXbdu3RQWFqbp06f7bDtt2rTj7qO6x+ZERUdHV/g5lJaW+tyPpV/+z6akpAR8Ng7/cUYYJI0bN9b8+fN1zTXXqHnz5rruuuuUkZGhgoICzZkzR3v37tUzzzzj82YO6ZczvT59+ujZZ59VUVGRHn744Qq3/dhjj6ljx45q3ry5hg0bpszMTO3atUvvvvuuvv32W5/PnlVXhw4dlJiYqEGDBunWW2+Vx+PRggULqvylFhYWpn79+mnGjBkKDQ1V//79fa6Pi4vTzJkzNWDAALVu3Vr9+vVT/fr19fXXX+s///mPLrroIs2YMUOSNHHiRPXs2VMdO3bU0KFDtX//fk2fPl1Nmzat9BdXTWrTpo0k6e6771a/fv0UFhamyy+/XFlZWbr//vv1j3/8QwUFBerdu7diY2O1bds2LV26VDfccINGjRql8PBwjRkzRrfccosuvvhi5eXlqaCgQPPmzVNWVla1/3Znr169NG7cOA0ZMkQdOnTQxx9/rIULF1Z4XSkrK0sJCQl6/PHHFRsbq+joaLVv314ZGRl68skn1b17dzVt2lRDhgxRamqqvvvuO61atUpxcXF66aWXJEljx47Vq6++quzsbI0YMUIlJSXe4328p/Ml6eqrr9amTZs0ceJEvffee+rXr58yMjJUVFSkTZs26ZlnnlFsbOxxX7uTpEsvvVTh4eG6/PLLNXz4cP3www+aPXu2kpKSfB7o1a9fX6NGjdLEiRPVq1cv9ejRQx9++KFeeeUVnzPmyoSEhFT72JyINm3a6PXXX9eUKVOUkpKijIwMnXPOOWrYsKGuvPJKtWzZUjExMXr99de1fv16PfLIIye8D9SQYLxVFb/auHGj69+/v0tOTnZhYWGuQYMGrn///u7jjz+ucsyKFSucJOfxeNw333xT6TZbt251AwcOdA0aNHBhYWEuNTXV9erVyy1evNi7TflHJNavX19hfGUfn1i7dq3705/+5KKiolxKSoq788473fLlyyt8Jqvce++95yS5Sy+9tMrvZdWqVS43N9fFx8e7yMhIl5WV5QYPHuzef/99n+2ef/55d95557mIiAjXpEkTt2TJEjdo0KCAPj5R2VvY09LSKrzlffz48S41NdWFhIRUOCbPP/+869ixo4uOjnbR0dHu3HPPdTfddJP74osvfG7j0UcfdWlpaS4iIsJdcMEFbu3ata5Nmzbusssu8zkWktxzzz1XYV7FxcXub3/7m0tOTnZRUVHuoosucu+++67Lycnx+QiGc798hKFJkyauVq1aFT5K8eGHH7o+ffq4unXruoiICJeWluby8vLcypUrfW5jzZo1rk2bNi48PNxlZma6xx9/3PvRgepavXq1u/LKK7337bi4ONe2bVs3evRot2PHDp9t09LSXM+ePSu9nRdffNG1aNHCRUZGuvT0dDdp0iT3r3/9q8LPorS01I0dO9Z7jDp37uw2bdpU4Wda2ecIq3tsyo/Bnj17fMZW9v/l888/d506dXJRUVHej3AcOXLE3XHHHa5ly5YuNjbWRUdHu5YtW7r8/PxqH1fUPI9zJ/A8BXACNmzYoFatWumpp57SgAEDgj2dU0pZWZnq16+vPn36aPbs2cGeDmAarxHipJk9e7ZiYmLUp0+fYE8lqIqLiys8hfzUU09p//79Pn9iDUBw8BohatxLL72kTz/9VE888YRuvvlm83/E+7///a9uu+02XXXVVapbt64++OADzZkzR82aNdNVV10V7OkB5vHUKGpcenq6du3apdzcXC1YsOC4f0HnTFdQUKBbb71V7733nvbv3686deqoR48eevDBB5WUlBTs6QHmEUIAgGm8RggAMI0QAgBMq9abZcrKyrR9+3bFxsZW+wPAAAAEi3NOhYWFSklJ8a7cUpVqhXD79u1q1KhRjUwOAIDfyzfffKOGDRsec5tqhbD8XX8d1UO1FBb4zAAAOIlK9LPe1svVetd6tUJY/nRoLYWplocQAgBOcf//8xDVeTmPN8sAAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwLRq/a1RAMcWmpjo91hPQlxA+z7UpoHfY0OLXUD7jt56wO+xnoOFfo8t2bHT77HAb3FGCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA01iPEBWEREYGNj4xwe+xwVxnrujK9n6P3dMyeI8pM58/5P/gz78MaN+lxcUBjQdOBZwRAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANNYhgkVlAW4tE5ZEJdSCkT04nUBjK3BiZygsuDtGn74+dK2fo8Ne+39GpwJynFGCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA01iPEDjNhSYm+j229MCBGpyJDYEcb0lKv/8Tv8cWvBbQrlEFzggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaSzDBJzmgrmUUkhkpN9jy4qLa3AmJyaQeQd6vAsuCGg4TgLOCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBpLMMEBFkgSwJJwV3OKFj7Dj2vcUDjXUSY//v+akdA+/YkxPk9tmTbVwHtG5XjjBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKaxHiEQZMFcT/B0VZSVGND42t/+4PfYlz9ZFdC+c1NaBTQeNY8zQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAayzABCIqvn2vu99i6izwB7TvkUJHfY3s07RLQvkMDWEHKExnh99iSHTv93/EZjjNCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYxnqEZ6iQyEi/x5YVF9fgTIDKnXXVx0Hbd0nQ9oxTEWeEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDSWYTpTnZvp/9iPPq25eQBVCGnVJGj7LgvgPh6amBjQvksPHPB7bK3kBn6PLdmx0++xZzrOCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBpLMN0hvJ8tcPvsaHnNQ5o36WfbQ5oPGwIZCmkYApkGaVAsZTSycEZIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATGM9wjOUJzLC77ElrCeI30FIZKT/YxMTAto36/rhaJwRAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANNYhukMVXbgYLCnABxTWXGx32N5BI+axP0JAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmMYyTMdRlnO+32ND1nxYgzM5MYEscQOc6kp27Az2FPwWEhnp99iAlq4KYL+B7vtUxxkhAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMYz3C4wjmmoIAzjzBWtfvTF5PMFCcEQIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTWIbpOGolN/B7bMmOnTU4kxNzus4bJy4kMtLvscFcmsfivKXgzf10nffvgTNCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYxnqEx3G6rs13us4bJ+50XSfudJ336YrjXTXOCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBpLMMEACeA5YzOPJwRAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANNYhukUVSsjLaDxJdu+qqGZAKee0PMaBzS+9LPNNTST00dIZGRA48/k5ac4IwQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmsR3gShSYm+j32x8b1A9p3GOsR4hQX0Pp4O/fW3ER+Z4GspfjFDXX9HttwZZnfYyUp8t/vBTT+VMYZIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNZZhOotIDB/weG/ba+zU4E5zJAlnuK5D7aKDKiov9HxzIWEmzv37b77HDzuoY0L5LP9vs99izb/N/LKrGGSEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAExjPULgNBfMNQWD5edL2wY0vqDko5qZCM4InBECAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA01iGCcBpJ3L91oDGj7nxer/Hhun9gPaNUw9nhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0lmECcNrxJMQFbd9FV7YPaHz04nU1NBPUFM4IAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGusRAqe5kMhIv8eWFRfX4Ex+PyXbvgpofFgA438YfGFA+44OaDROBs4IAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGkswwQEWeh5jQMa/8UNdf0e23BlWUD7rv36Rr/HBnMJqFrJDfwemzjv3RqcCU4FnBECAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA01iMEgqz0s80BjT/7tsDGByKw1QyDp2THzmBPAacQzggBAKYRQgCAaYQQAGAaIQQAmEYIAQCmEUIAgGmEEABgGiEEAJhGCAEAphFCAIBphBAAYBohBACYRggBAKZVa/UJ55wkqUQ/S+6kzgcAgICV6GdJv/brWKoVwsLCQknS23o5gGkBAPD7KiwsVHx8/DG38bhq5LKsrEzbt29XbGysPB5PjU0QAICTwTmnwsJCpaSkKCTk2K8CViuEAACcqXizDADANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATCOEAADTCCEAwDRCCAAwjRACAEwjhAAA0wghAMA0QggAMI0QAgBMI4QAANMIIQDANEIIADCNEAIATPt/ZsIt4GUxgPUAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualization(noise_scale=0.001, model=global_model, input=input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d514caee-9541-49e4-9233-aca655d83322",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_capsule(model, device, test_loader):\n",
    "    model.eval()\n",
    "    correct, total = 0, 0\n",
    "    for images, labels in test_loader:\n",
    "        # Add channels = 1\n",
    "        images = images.to(device)\n",
    "        # Categogrical encoding\n",
    "        labels = torch.eye(10).index_select(dim=0, index=labels).to(device)\n",
    "        logits, reconstructions, primary_caps_output, digit_caps_output, c, b = model(images)\n",
    "        pred_labels = torch.argmax(logits, dim=1)\n",
    "        correct += torch.sum(pred_labels == torch.argmax(labels, dim=1)).item()\n",
    "        total += len(labels)\n",
    "\n",
    "    print('Accuracy: {}'.format(correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1a3cf32a-390c-4657-b88e-00f85b0e2749",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9203\n",
      "Accuracy: 0.9958166666666667\n"
     ]
    }
   ],
   "source": [
    "test_capsule(global_model, device, test_loader)\n",
    "test_capsule(global_model, device, train_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "677948c1-4db5-4283-a4c4-7aff14e5e180",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visual_images(model, index):\n",
    "    input = images[index].unsqueeze(0)\n",
    "    label = labels[index]\n",
    "    input.requires_grad = True\n",
    "    model.eval()\n",
    "    ground_truth_predictions, reconstruction, primary_caps_output, digit_caps_output, c, b = model(input)\n",
    "    _, predicted_class_index = torch.max(ground_truth_predictions, 1)\n",
    "    is_correct = (predicted_class_index == labels[index]).item()\n",
    "    original_image = images[index].view(28, 28).cpu().detach().numpy()\n",
    "    reconstructed_image = reconstruction.view(28, 28).cpu().detach().numpy()\n",
    "    actual_class = classes[labels[index].item()]\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n",
    "    axes[0].imshow(original_image, cmap='gray')\n",
    "    axes[0].set_title(\"Original Image - \" + actual_class)\n",
    "    axes[0].axis('off')  # 关闭坐标轴\n",
    "    axes[1].imshow(reconstructed_image, cmap='gray')\n",
    "    axes[1].set_title(\"Reconstructed Image\" + (\" - Correct\" if is_correct else \" - Incorrect\"))\n",
    "    axes[1].axis('off')  # 关闭坐标轴"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "95794864-b73a-4206-970b-ddafabde884c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu4AAAFeCAYAAADaP5oiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAArZUlEQVR4nO3deXhU5aHH8V+2mewhAcIugYBsolIQq6yKlYuAsklFCQSQ1Q0fwEtrEUUfLbZUfLwqaavAFb0KiEhbEehVoaCtigjIvgtcIISAkJ1k3vuHT6YMYXknJIYXvp/n4XnkzC8z7xwP7/nNyZlzQowxRgAAAAAua6FVPQAAAAAAF0dxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHGvBE8//bRCQkLK9bNz5sxRSEiI9u7dW7GDOsPevXsVEhKiOXPmVNprAABwOWNfCBdR3M+wadMmDR48WPXq1ZPX61XdunX1wAMPaNOmTVU9tCrx2WefKSQkRAsXLqzqoVS50g9jF/vTtWvXqh4qgEpUenCl9E94eLjq1aun9PR0HTx4sKqHV+Fee+21Ki+2VT0G9oXnVlJSotmzZ6tr165KSkqS1+tVSkqKhg0bpq+//rqqh1cuVb2t2Qiv6gFcLhYtWqRBgwYpKSlJI0aMUKNGjbR371698cYbWrhwod5991317dvX6rl+85vfaPLkyeUaR1pamu677z55vd5y/TwqR79+/dSkSRP/33NycjR27Fj17dtX/fr18y+vVatWVQwPwE9s2rRpatSokQoKCvTPf/5Tc+bM0erVq/Xdd98pMjKyqodXYV577TXVqFFD6enpV/UYECg/P1/9+vXTxx9/rM6dO+vXv/61kpKStHfvXs2fP19z587V999/r/r161f1UIPiwrZGcZe0a9cupaWlqXHjxlq1apVq1qzpf+yxxx5Tp06dlJaWpg0bNqhx48bnfZ7c3FzFxMQoPDxc4eHlW7VhYWEKCwsr18+i8lx//fW6/vrr/X/PysrS2LFjdf3112vw4MHn/bmCggJ5PB6Fhrr1y63i4mL5fD55PJ6qHgpwWerRo4fatWsnSXrwwQdVo0YNTZ8+XUuWLNHAgQOreHRVo3QfiCvfpEmT9PHHH+ull17S+PHjAx6bOnWqXnrppQp5nQttU3l5eYqOjq6Q13GJW22ikvzud79TXl6e/vjHPwaUdkmqUaOGMjIylJubqxdffNG/vPTUic2bN+v+++9XYmKiOnbsGPDYmfLz8/Xoo4+qRo0aiouL0913362DBw8qJCRETz/9tD93rnPcU1JS1KtXL61evVrt27dXZGSkGjdurP/+7/8OeI3s7GxNnDhRrVu3VmxsrOLj49WjRw+tX7++gtbUv9/b9u3bNXjwYCUkJKhmzZqaMmWKjDHav3+/7rnnHsXHx6t27dqaMWNGwM8XFRXpqaeeUtu2bZWQkKCYmBh16tRJn376aZnXOnbsmNLS0hQfH69q1app6NChWr9+/TnPSdy6dasGDBigpKQkRUZGql27dlqyZEmFvW8bpb9Offfdd/Wb3/xG9erVU3R0tE6ePClJWrBggdq2bauoqCjVqFFDgwcPLvOr9a5du57zdJv09HSlpKQELHv33XfVtm1bxcXFKT4+Xq1bt9bLL78ckDlx4oTGjx+vBg0ayOv1qkmTJpo+fbp8Pp8/U3qe5+9//3vNnDlTqamp8nq92rx5c8WsGOAq0KlTJ0k/Hgg6k+3cdOLECT3++ONKSUmR1+tV/fr1NWTIEGVlZfkzmZmZGjFihGrVqqXIyEjdcMMNmjt3bsDznPnv+Y9//KP/3/NNN92kr776KiB7+PBhDRs2TPXr15fX61WdOnV0zz33+Pc/KSkp2rRpk1auXFnmdMDSfdXKlSs1btw4JScn+4+unmu+ks7//a958+apffv2io6OVmJiojp37qzly5dfdAyl6+1ic1xpLj09XQkJCf79yYkTJ8qMxdbVvC88cOCAMjIy9Itf/KJMaZd+PAA5ceLEgKPt69atU48ePRQfH6/Y2Fh169ZN//znPwN+7kLbVNeuXXXddddp7dq16ty5s6Kjo/XrX/9aklRYWKipU6eqSZMm8nq9atCggZ544gkVFhaWGdulbGuXC464S/rLX/6ilJQU/8R7ts6dOyslJUV/+9vfyjx27733qmnTpnr++edljDnva6Snp2v+/PlKS0vTz3/+c61cuVI9e/a0HuPOnTs1YMAAjRgxQkOHDtWbb76p9PR0tW3bVq1atZIk7d69W4sXL9a9996rRo0a6ciRI8rIyFCXLl20efNm1a1b1/r1LuaXv/ylWrRood/+9rf629/+pueee05JSUnKyMjQ7bffrunTp+vtt9/WxIkTddNNN6lz586SpJMnT+rPf/6zBg0apJEjR+rUqVN644031L17d3355Ze68cYbJUk+n0+9e/fWl19+qbFjx6p58+b68MMPNXTo0DJj2bRpkzp06KB69epp8uTJiomJ0fz589WnTx+9//771qc4VZRnn31WHo9HEydOVGFhoTwej+bMmaNhw4bppptu0gsvvKAjR47o5Zdf1po1a7Ru3TpVq1YtqNdYsWKFBg0apG7dumn69OmSpC1btmjNmjV67LHHJP14NKJLly46ePCgRo8erWuuuUaff/65fvWrX+nQoUOaOXNmwHPOnj1bBQUFGjVqlLxer5KSkipidQBXhdKym5iY6F9mOzfl5OSoU6dO2rJli4YPH66f/exnysrK0pIlS3TgwAHVqFFD+fn56tq1q3bu3KmHH35YjRo10oIFC5Senq4TJ074/92Xeuedd3Tq1CmNHj1aISEhevHFF9WvXz/t3r1bERERkqT+/ftr06ZNeuSRR5SSkqLMzEytWLFC33//vVJSUjRz5kw98sgjio2N1ZNPPimp7OmA48aNU82aNfXUU08pNzc36PX2zDPP6Omnn9att96qadOmyePx6F//+pc++eQT3XnnnRccg+0cZ4zRPffco9WrV2vMmDFq0aKFPvjgg3PuT4J1Ne4Lly5dquLiYqWlpVnlN23apE6dOik+Pl5PPPGEIiIilJGRoa5du2rlypW6+eabA/Ln26aOHTumHj166L777tPgwYNVq1Yt+Xw+3X333Vq9erVGjRqlFi1aaOPGjXrppZe0fft2LV682P/zl7KtXVbMVe7EiRNGkrnnnnsumLv77ruNJHPy5EljjDFTp041ksygQYPKZEsfK7V27VojyYwfPz4gl56ebiSZqVOn+pfNnj3bSDJ79uzxL2vYsKGRZFatWuVflpmZabxer5kwYYJ/WUFBgSkpKQl4jT179hiv12umTZsWsEySmT179gXf86effmokmQULFpR5b6NGjfIvKy4uNvXr1zchISHmt7/9rX/58ePHTVRUlBk6dGhAtrCwMOB1jh8/bmrVqmWGDx/uX/b+++8bSWbmzJn+ZSUlJeb2228vM/Zu3bqZ1q1bm4KCAv8yn89nbr31VtO0adMLvsfyOnr0aJn/d6Xrq3HjxiYvL8+/vKioyCQnJ5vrrrvO5Ofn+5f/9a9/NZLMU0895V/WpUsX06VLlzKvN3ToUNOwYUP/3x977DETHx9viouLzzvGZ5991sTExJjt27cHLJ88ebIJCwsz33//vTHm39tDfHy8yczMtF0FwFWpdI7++9//bo4ePWr2799vFi5caGrWrGm8Xq/Zv3+/P2s7Nz311FNGklm0aFGZ1/P5fMYYY2bOnGkkmXnz5vkfKyoqMrfccouJjY3175tK/z1Xr17dZGdn+7MffvihkWT+8pe/GGN+nHclmd/97ncXfL+tWrU655xUuh46duxYZh46e74qdfa+cceOHSY0NNT07du3zL6r9H1faAy2c9zixYuNJPPiiy/6M8XFxaZTp07sC8vh8ccfN5LMunXrrPJ9+vQxHo/H7Nq1y7/s//7v/0xcXJzp3Lmzf9mFtqkuXboYSWbWrFkBy9966y0TGhpq/vGPfwQsnzVrlpFk1qxZY4y59G3tcnLVnypz6tQpSVJcXNwFc6WPl572UGrMmDEXfY2PP/5Y0o+fIs/0yCOPWI+zZcuWAb8RqFmzppo1a6bdu3f7l3m9Xv+51CUlJTp27JhiY2PVrFkzffPNN9avZePBBx/0/3dYWJjatWsnY4xGjBjhX16tWrUyYwwLC/OfN+3z+ZSdna3i4mK1a9cuYIwff/yxIiIiNHLkSP+y0NBQPfTQQwHjyM7O1ieffKKBAwfq1KlTysrKUlZWlo4dO6bu3btrx44dP/mVHoYOHaqoqCj/37/++mtlZmZq3LhxAV9a69mzp5o3b37O3+RcTLVq1ZSbm6sVK1acN7NgwQJ16tRJiYmJ/vWSlZWlO+64QyUlJVq1alVAvn///mVOFQNwbnfccYdq1qypBg0aaMCAAYqJidGSJUv8v9oPZm56//33dcMNN5zziGjpqSUfffSRateurUGDBvkfi4iI0KOPPqqcnBytXLky4Od++ctfBhz9L91/lM7HUVFR8ng8+uyzz3T8+PFyr4eRI0eW+3tZixcvls/n01NPPVXme0A2l1S2neM++ugjhYeHa+zYsf6fDQsLC2offD5X476wtAddrDdJP3aR5cuXq0+fPgHfEaxTp47uv/9+rV69ukyvOt825fV6NWzYsIBlCxYsUIsWLdS8efOAbeD222+XJP+pR5e6rV1OrvpTZUo3vNICfz7nK/iNGjW66Gvs27dPoaGhZbJnXqXkYq655poyyxITEwMmXJ/Pp5dfflmvvfaa9uzZo5KSEv9j1atXt36t8ownISFBkZGRqlGjRpnlx44dC1g2d+5czZgxQ1u3btXp06f9y89cP/v27VOdOnXKfPHk7HW2c+dOGWM0ZcoUTZky5ZxjzczMVL169c752NGjRwPWU2xsrGJjY8+ZtXX2/+d9+/ZJkpo1a1Ym27x5c61evTro1xg3bpzmz5+vHj16qF69errzzjs1cOBA/cd//Ic/s2PHDm3YsOG8ZTwzM/OC4wZwfq+++qquvfZa/fDDD3rzzTe1atWqgKuBBTM37dq1S/3797/g6+3bt09NmzYtUzpatGjhf/xMZ8/RpSW+dJ/h9Xo1ffp0TZgwQbVq1dLPf/5z9erVS0OGDFHt2rUt1sCPLmXe2LVrl0JDQ9WyZcty/bztHFe6Pzl7bj/XnBysq3FfGB8fL+nivan0efPy8s65rlu0aCGfz6f9+/f7T/mVzr9N1atXr8wFE3bs2KEtW7ZcdBu41G3tcnLVF/eEhATVqVNHGzZsuGBuw4YNqlevnn+DLXXmkdXKdL4jGuaM8+qff/55TZkyRcOHD9ezzz6rpKQkhYaGavz48WW+qFMZ47EZ47x585Senq4+ffpo0qRJSk5OVlhYmF544YUyX+qyUfq+Jk6cqO7du58zc6EPSDfddFPADm/q1KkBXxYuj0vZJkJCQs75XYkzJ1RJSk5O1rfffqtly5Zp6dKlWrp0qWbPnq0hQ4b4v6zm8/n0i1/8Qk888cQ5X+vaa6+tsHEDV5v27dv7ryrTp08fdezYUffff7+2bdum2NjYS56bLpXNfDx+/Hj17t1bixcv1rJlyzRlyhS98MIL+uSTT9SmTRur1znXvHG+I5hnz2OXKtg5rjJcjfvC5s2bS5I2btzoPxe/Ip1vX3Su5T6fT61bt9Yf/vCHc/5MgwYNKnRsl4OrvrhLUq9evfSnP/1Jq1ev9l8Z5kz/+Mc/tHfvXo0ePbpcz9+wYUP5fD7t2bNHTZs29S/fuXNnucd8LgsXLtRtt92mN954I2D5iRMnynz6ryoLFy5U48aNtWjRooDJferUqQG5hg0b6tNPPy1zuaez11npr94iIiJ0xx13BD2et99+W/n5+WWeryI1bNhQkrRt2zb/r+9Kbdu2zf+49ONRsTN/nVrq7KNpkuTxeNS7d2/17t1bPp9P48aNU0ZGhqZMmaImTZooNTVVOTk55VovAOyVFq7bbrtN//Vf/6XJkycHNTelpqbqu+++u2CmYcOG2rBhg3w+X8BR961bt/ofL4/U1FRNmDBBEyZM0I4dO3TjjTdqxowZmjdvnqTynUaQmJh4ziu2nD2PpaamyufzafPmzRcsgOcbg+0c17BhQ/3v//6vcnJyAo4ib9u27YI/V5lc3hf26NFDYWFhmjdv3kW/oFqzZk1FR0efc11v3bpVoaGhl1SuU1NTtX79enXr1u2C2+qlbmuXk6v+HHfpx+uRRkVFafTo0WV+lZWdna0xY8YoOjpakyZNKtfzl376fe211wKWv/LKK+Ub8HmEhYWVOVq7YMGCy+pufqVHIs4c57/+9S998cUXAbnu3bvr9OnT+tOf/uRf5vP59OqrrwbkkpOT1bVrV2VkZOjQoUNlXu/o0aMXHE+HDh10xx13+P9URnFv166dkpOTNWvWrIDLUy1dulRbtmwJuLpQamqqtm7dGjDu9evXa82aNQHPefZ2Ghoa6r/OfOlrDBw4UF988YWWLVtWZkwnTpxQcXHxpb85AJJ+vFxd+/btNXPmTBUUFAQ1N/Xv31/r16/XBx98UCZXOlfeddddOnz4sN577z3/Y8XFxXrllVcUGxurLl26BDXevLw8FRQUBCxLTU1VXFxcwDwVExMT9GUTU1NT9cMPPwT8JvvQoUNl3l+fPn0UGhqqadOmlfmt8Jn7iPONwXaOu+uuu1RcXKzXX3/d/3hJSUmF74OD4fK+sEGDBho5cqSWL19+znXo8/k0Y8YMHThwQGFhYbrzzjv14YcfBlzm+siRI3rnnXfUsWPHMmcyBGPgwIE6ePBgwPoplZ+f778qzaVua5cTjrhLatq0qebOnasHHnhArVu3LnPn1KysLP3P//yPUlNTy/X8bdu2Vf/+/TVz5kwdO3bMfznI7du3S6q4T3i9evXStGnTNGzYMN16663auHGj3n777Uopo+XVq1cvLVq0SH379lXPnj21Z88ezZo1Sy1btlROTo4/16dPH7Vv314TJkzQzp071bx5cy1ZskTZ2dmSAtfZq6++qo4dO6p169YaOXKkGjdurCNHjuiLL77QgQMHKvQ69uURERGh6dOna9iwYerSpYsGDRrkvxxkSkqKHn/8cX92+PDh+sMf/qDu3btrxIgRyszM1KxZs9SqVauAL/A8+OCDys7O1u2336769etr3759euWVV3TjjTf6z3mdNGmSlixZol69evkvHZqbm6uNGzdq4cKF2rt372XzmxjgSjBp0iTde++9mjNnjsaMGWM9N02aNEkLFy7Uvffeq+HDh6tt27bKzs7WkiVLNGvWLN1www0aNWqUMjIylJ6errVr1yolJUULFy7UmjVrNHPmTKsvCp5p+/bt6tatmwYOHKiWLVsqPDxcH3zwgY4cOaL77rvPn2vbtq1ef/11Pffcc2rSpImSk5PL/ObwbPfdd5/+8z//U3379tWjjz6qvLw8vf7667r22msDvnjZpEkTPfnkk3r22WfVqVMn9evXT16vV1999ZXq1q2rF1544YJjsJ3jevfurQ4dOmjy5Mnau3evWrZsqUWLFumHH34Iap1VJNf3hTNmzNCuXbv06KOPatGiRerVq5cSExP1/fffa8GCBdq6dat/O3ruuee0YsUKdezYUePGjVN4eLgyMjJUWFgYcH+c8khLS9P8+fM1ZswYffrpp+rQoYNKSkq0detWzZ8/X8uWLVO7du0ueVu7rPz0F7K5fG3YsMEMGjTI1KlTx0RERJjatWubQYMGmY0bN5bJll4K6ujRo+d97Ey5ubnmoYceMklJSSY2Ntb06dPHbNu2zUgKuGzU+S4H2bNnzzKvc/alAwsKCsyECRNMnTp1TFRUlOnQoYP54osvyuQq4nKQZ7/voUOHmpiYmHOOsVWrVv6/+3w+8/zzz5uGDRsar9dr2rRpY/7617+e8/JhR48eNffff7+Ji4szCQkJJj093axZs8ZIMu+++25AdteuXWbIkCGmdu3aJiIiwtSrV8/06tXLLFy48ILvsbwudDnIM9fXmd577z3Tpk0b4/V6TVJSknnggQfMgQMHyuTmzZtnGjdubDwej7nxxhvNsmXLyqyfhQsXmjvvvNMkJycbj8djrrnmGjN69Ghz6NChgOc6deqU+dWvfmWaNGliPB6PqVGjhrn11lvN73//e1NUVGSM+ff2cLHLwgH49xz91VdflXmspKTEpKammtTUVP/l7GznpmPHjpmHH37Y1KtXz3g8HlO/fn0zdOhQk5WV5c8cOXLEDBs2zNSoUcN4PB7TunXrMvP4hf49nzlnZWVlmYceesg0b97cxMTEmISEBHPzzTeb+fPnB/zM4cOHTc+ePU1cXJyR5N+XXGg9GGPM8uXLzXXXXWc8Ho9p1qyZmTdv3jn3jcYY8+abb/rnxsTERNOlSxezYsWKi47BGLs5rnT9pqWlmfj4eJOQkGDS0tLMunXr2BdeguLiYvPnP//ZdOrUySQkJJiIiAjTsGFDM2zYsDKXivzmm29M9+7dTWxsrImOjja33Xab+fzzzwMyF9qmzl5/ZyoqKjLTp083rVq18m9Dbdu2Nc8884z54YcfArKXsq1dLkKMucBdg1Cpvv32W7Vp00bz5s3TAw88UNXDccLixYvVt29frV69Wh06dKjq4QAA8JNjX3j14hz3n8iZX/ooNXPmTIWGhvrvpIZAZ6+z0nMS4+Pj9bOf/ayKRgUAwE+HfSHOxDnuP5EXX3xRa9eu1W233abw8HD/JfxGjRp1RV6uqCI88sgjys/P1y233KLCwkItWrRIn3/+uZ5//nkuXQgAuCqwL8SZOFXmJ7JixQo988wz2rx5s3JycnTNNdcoLS1NTz75pMLD+fx0Lu+8845mzJihnTt3qqCgQE2aNNHYsWP18MMPV/XQAAD4SbAvxJko7gAAAIADOMcdAAAAcADFHQAAAHAAxR0AAABwgPW3Iivq7p64dDVr1rTOjho1yjobzF3kznV5y4oQ7J3sgvmKRuktpm14PB7rbGZmpnX2s88+s84WFRVZZxE8vt5zZWDfBOBKYbNf4og7AAAA4ACKOwAAAOAAijsAAADgAIo7AAAA4ACKOwAAAOAAijsAAADgAIo7AAAA4ACKOwAAAOAAijsAAADgAIo7AAAA4IDwqh4AgjdgwADr7JQpU6yz2dnZ1tlDhw5ZZxs3bmydPXDggHVWknbs2GGdbdGihXW2oKDAOvv3v//dOlurVi3r7FtvvWWdBQCXvPfee9bZjh07Wmejo6Ots9WqVbPOBrNvio2Ntc7u3r3bOrt//37rbJ8+fayzcAtH3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHhFf1ABC85ORk6+zevXutsyUlJeUYzcUdOnTIOhsWFhbUc1evXt06Gx8fb509efKkdbZu3brW2a1bt1pnAeBKdfDgQevs3LlzrbOnTp2yzjZr1sw6Gx0dbZ0NZv+xZ88e6+zRo0etsw0bNrTO7tu3zzqLqscRdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMAB4VU9AASvevXq1tlgbpHcuHFj62x2drZ1Ni4uzjqbk5NjnZWkatWqWWdDQkKss8GM2efzWWc3btxonQWAK1WLFi2ss19//bV1NiwszDpbVFRknT127Jh1Njc31zobGRlpnY2JibHO1qlTxzq7b98+6yyqHkfcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAeEV/UAELxgbk98ww03WGd9Pl+lZPPy8qyzwdyCWpJCQ+0/ex4+fNg6m5SUVClj2Lp1q3UWAK5UwezHsrKyrLMRERHW2WD2TTExMdbZgoKCSskeOnTIOosrF0fcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAeEV/UAEDyfz2ed3bBhg3U2NzfXOhsSEmKdTU1Ntc4mJiZaZ4Mdx44dO4J6blu7d++2zhYXF1fKGADAJfv377fOZmZmWmfr169vna2s+TgqKso6e+DAAevsqVOnrLPGGOss3MIRdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMAB4VU9AAQvmFsZB3M75c2bN5dnOBc1YMAA62z16tWDeu5WrVpZZ1etWmWdXbt2rXX24MGD1lmPx2OdzcvLs84CgEv2799vnc3KyrLOVqtWzTpbo0YN62x0dLR1NiQkxDobzHsrLCy0zubn51tn4RaOuAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOCK/qASB4W7Zssc5269atUp43mFsvb9682Tr75ZdfWmclKSMjwzobzC22Dxw4YJ09fvy4dZbbUAOAlJeXZ50NZt4sKCiwzh47dsw6u2nTJuvskCFDrLOrV6+2zlbWeoBbOOIOAAAAOIDiDgAAADiA4g4AAAA4gOIOAAAAOIDiDgAAADiA4g4AAAA4gOIOAAAAOIDiDgAAADiA4g4AAAA4gOIOAAAAOCC8qgeA4EVHR1tnc3NzrbO1a9e2zh4/ftw6G4zw8OA2Sa/Xa50NDbX/nBrM7aKLi4uts5GRkdbZwsJC6ywAuCSYOTYiIsI6Gxsba53dvHmzdXb58uXW2UmTJllng9nnhYSEWGeLioqss3ALR9wBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAABwR3f3lcFnJzc62z0dHR1lmfz2edrVu3rnU2mFs6r1u3zjorScYY62xUVJR1NphbbIeFhVlnT58+bZ0FgCtVSUlJpTxvbGysdXb37t3W2WDm7mD2u8HsP4J5b8HsG+EWjrgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADrC/Fz0uG3l5edZZn89nnc3JySnPcCr0eb/99ttKGYMkRUVFWWcLCgqss4WFhdbZYG6bDQBXqpKSEutsRESEdTY2NtY6e/ToUeusMcY6G8x44+LirLPBvLdg1i/cwhF3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAHhVT0ABM/n81lnT58+bZ0N5pbOwWRzcnKss8HKz8+3zno8Hutsbm6udba4uNg6y22oAUDKy8uzzlarVs06GxkZaZ09efKkdTYYx48ft84Gsy+NiIiwzhYWFlpn4RaOuAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOCK/qASB4WVlZ1tlgbqccGmr/Oc7j8VhnCwoKrLPBysnJsc6GhIRYZ4MZ88GDB62zPp/POgsAV6rs7GzrbFJSknW2qKjIOltcXGydDca2bduss2FhYdbZU6dOWWdPnz5tnYVbOOIOAAAAOIDiDgAAADiA4g4AAAA4gOIOAAAAOIDiDgAAADiA4g4AAAA4gOIOAAAAOIDiDgAAADiA4g4AAAA4gOIOAAAAOCC8qgeA4B06dMg66/F4KmUM0dHR1tmIiIhKGYMkhYfbb8K5ubnW2ZMnT1png7llNQBAysvLs876fL5KeV5jjHU2GHv27LHOBrN/zMnJsc4WFRVZZ+EWjrgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADrC/XzwuG8Hc0jmYbG5urnU2NNT+M19SUpJ1NljBjNnr9VpnCwoKrLPHjh2zzgIApMLCQutsZGSkdTYzM9M6a4yxzgZj//791tnExETr7OnTpyslC7dwxB0AAABwAMUdAAAAcADFHQAAAHAAxR0AAABwAMUdAAAAcADFHQAAAHAAxR0AAABwAMUdAAAAcADFHQAAAHAAxR0AAABwQHhVDwDBKykpsc7m5ORYZ0ND7T/HhYfbbzpHjx61zgZrx44d1tmoqCjrrMfjsc4GcztuAIB0+vRp62xERIR11ufzWWeNMdbZYBw8eNA6W79+fetscXGxdbay3huqHkfcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAfY37ceTgrmVtGJiYnW2fBw+03n+PHj1tlgbd682TobzK2l4+PjrbN5eXnWWQCAVFBQYJ0tLi62zl4O8/Hu3buts23atLHO5ubmWmeNMdZZuIUj7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIAD7O9bDydVr17dOrtjxw7r7F133WWdzcjIsM4G65tvvrHOtm/f3jp74MAB62xYWJh1FgAQnOjoaOtsaGjVH4/Mzc21zlarVs06GxMTU47R4EpT9Vs4AAAAgIuiuAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA4Ir+oBoHJ16dLFOpuammqd7dGjh3U2LS3NOhus7777zjqblJRknX344Yetsxs2bLDOrl271joLAFeqkJAQ66zP57POhoZW/fHI/Px862xMTIx1Ni4urjzDwRWm6rdwAAAAABdFcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABwQXtUDQPCCuVV0WFiYdbZp06bW2Z07d1pnCwoKrLPBKi4uts4mJCRYZ2+++WbrbEREhHUWACCFhtofN4yOjrbORkZGlmc4FaqwsNA66/F4rLNxcXHlGQ6uMBxxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABwQXtUDQPCMMdbZYG6nHBUVZZ0N5pbOlSkiIsI6Gx5uv7knJCRUyvMCACSfz2edDWY+rlmzZnmGU6GCeW/JycnW2WrVqllnQ0JCrLNwC0fcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdwr/YrXFFRkXU2Pj7eOpubm1ue4VS44uJi62xJSYl1NiIiwjp7+PBh6ywAILi5OyYmxjobEhJSnuFUqGD2NeHh9jUsmP2Sz+ezzsItHHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHEBxBwAAABxAcQcAAAAcQHEHAAAAHGB/r104KT8/3zobGRlpnS0oKCjPcCpcUVGRdTaYW2GHhtp/pj19+rR1FgAglZSUWGfj4uKss9HR0eUZToWqrPcWFhZmnTXGWGfhFo64AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA4Ir+oBoHLVrl3bOhvM7ZRDQy+Pz3w5OTnWWZ/PZ50NZl3k5+dbZwEAwc3HUVFR1tno6OjyDKdC5ebmWmcjIiKssyUlJeUZDq4wl0f7AgAAAHBBFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMABFHcAAADAARR3AAAAwAEUdwAAAMAB4VU9AFSuI0eOWGeTk5Ots8XFxeUZToU7fvy4dTaY20V7vV7rbGZmpnUWACD5fL5Ked6YmJhKed5gGGOss8Hsl0JD7Y+1BjMGuIUj7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADwqt6AKhcH330kXW2Xbt21tnKul11sE6dOmWdPXnypHU2MjLSOrt3717rLABAMsZUStY1p0+fts7m5eVV4kjgCo64AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA6guAMAAAAOoLgDAAAADqC4AwAAAA4Ir+oBoHIVFBRYZyMjI62zJSUl5RlOlYqKirLOxsTEWGcPHjxYnuEAwFXLGGOdHTduXCWOpGrdcsstVT0EOIYj7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADKO4AAACAAyjuAAAAgAMo7gAAAIADwqt6AKhcb731lnW2U6dO1tmlS5eWZzhVasmSJZXyvBs3bqyU5wUAADgTR9wBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB1DcAQAAAAdQ3AEAAAAHUNwBAAAAB4QYY0xVDwIAAADAhXHEHQAAAHAAxR0AAABwAMUdAAAAcADFHQAAAHAAxR0AAABwAMUdAAAAcADFHQAAAHAAxR0AAABwAMUdAAAAcMD/AxeXbfJm2/4tAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visual_images(global_model, 18)\n",
    "visual_images(global_model, 30)\n",
    "visual_images(global_model, 31)\n",
    "visual_images(global_model, 34)\n",
    "visual_images(global_model, 1)\n",
    "visual_images(global_model, 2)\n",
    "visual_images(global_model, 3)\n",
    "visual_images(global_model, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3451e2c9-dc8d-4197-88e2-31eee031de5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "label_list = list()\n",
    "for i, label in enumerate(labels):\n",
    "    label_list.append(f'{i}: {classes[label]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "83423e28-c85b-479b-ac25-a657ed1afda5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visual_images2(model, index):\n",
    "    input = images[index].unsqueeze(0)\n",
    "    label = labels[index]\n",
    "    input.requires_grad = True\n",
    "    model.eval()\n",
    "    ground_truth_predictions, reconstruction , primary_caps_output, digit_caps_output, c, b= model(input)\n",
    "    _, predicted_class_index = torch.max(ground_truth_predictions, 1)\n",
    "    print('--------------------')\n",
    "    print(f'The size of primary caps is {primary_caps_output.size()}')\n",
    "    print(f'The size of digit caps is {digit_caps_output.size()}')\n",
    "    print('--------------------')\n",
    "    print(f'The size of c is {c.size()}')\n",
    "    print(f'The size of b is {b.size()}')\n",
    "    return primary_caps_output, digit_caps_output, c, b\n",
    "def visualize_digit_caps_output(digit_caps_output):\n",
    "    caps_sizes = np.linalg.norm(digit_caps_output.squeeze().cpu().detach().numpy(), axis=1)\n",
    "    plt.bar(range(len(caps_sizes)), caps_sizes)\n",
    "    plt.xlabel('Capsule')\n",
    "    plt.ylabel('Size')\n",
    "    plt.title('Sizes of Digit Capsules')\n",
    "    plt.show()\n",
    "def visualize_top_n_primary_caps_for_digit_caps(c, digit_caps_index, top_n, threshold):\n",
    "    coupling_coeffs = c[0, digit_caps_index].squeeze()\n",
    "    indices = torch.where(coupling_coeffs > threshold)[0]\n",
    "    print(indices)\n",
    "    top_n_indices = coupling_coeffs.topk(top_n).indices\n",
    "    plt.figure(figsize=(10, 2))\n",
    "    plt.bar(range(top_n), coupling_coeffs[top_n_indices].cpu().detach().numpy())\n",
    "    plt.xlabel('Primary Capsule Index')\n",
    "    plt.ylabel('Coupling Coefficient')\n",
    "    plt.title(f'Top {top_n} Primary Capsules for Digit Capsule {digit_caps_index}')\n",
    "    plt.show()\n",
    "def visualize_top_n(c, digit_caps_index, top_n, threshold):\n",
    "    coupling_coeffs = c[0, digit_caps_index].squeeze()\n",
    "    indices = torch.where(coupling_coeffs > threshold)[0]\n",
    "    print(\"Indices of primary capsules with coupling coefficients above threshold:\", indices)\n",
    "    top_n_indices = coupling_coeffs.topk(top_n).indices\n",
    "    print(\"Top N primary capsules indices:\", top_n_indices)\n",
    "    plt.figure(figsize=(10, 2))\n",
    "    plt.bar(range(top_n), coupling_coeffs[top_n_indices].cpu().detach().numpy())\n",
    "    plt.xlabel('Primary Capsule Index')\n",
    "    plt.ylabel('Coupling Coefficient')\n",
    "    plt.title(f'Top {top_n} Primary Capsules for Digit Capsule {digit_caps_index}')\n",
    "    plt.show()\n",
    "    top_n_indices = list(top_n_indices)\n",
    "    return top_n_indices\n",
    "# #-----Select-----\n",
    "# def modify_primary_caps_output(primary_caps_output, indices):\n",
    "#     modified_output = torch.zeros_like(primary_caps_output)\n",
    "#     for index in indices:\n",
    "#         modified_output[:, index, :] = primary_caps_output[:, index, :]\n",
    "#     return modified_output\n",
    "# #-----Reconstruction-----\n",
    "# def reconstruct_image_with_selected_capsules(model, primary_caps_output, indices):\n",
    "#     modified_primary_caps_output= modify_primary_caps_output(primary_caps_output, indices)\n",
    "#     digit_caps_output, c, b = model.digit_caps(modified_primary_caps_output)\n",
    "#     logits = torch.norm(digit_caps_output, dim=-1)\n",
    "#     pred = torch.eye(10).to(model.device).index_select(dim=0, index=torch.argmax(logits, dim=1))\n",
    "#     batch_size = digit_caps_output.shape[0]\n",
    "#     reconstruction = model.decoder((digit_caps_output * pred.unsqueeze(2)).contiguous().view(batch_size, -1))\n",
    "#     image_size=(28, 28)\n",
    "#     image = reconstruction.view(*image_size).cpu().detach().numpy()\n",
    "#     plt.imshow(image, cmap='gray')\n",
    "#     plt.axis('off')\n",
    "#     plt.title(f'Capsule {indices}')\n",
    "#     plt.show()\n",
    "#     return reconstruction\n",
    "def modify_primary_caps_output_removal(primary_caps_output, indices):\n",
    "    modified_output = primary_caps_output.clone()\n",
    "    for index in indices:\n",
    "        modified_output[:, index, :] = 0\n",
    "    return modified_output\n",
    "\n",
    "def reconstruct_image_with_removal_selected_capsules(model, primary_caps_output, indices):\n",
    "    model.eval()\n",
    "    modified_primary_caps_output = modify_primary_caps_output_removal(primary_caps_output, indices)\n",
    "    digit_caps_output, c, b = model.digit_caps(modified_primary_caps_output)\n",
    "    logits = torch.norm(digit_caps_output, dim=-1)\n",
    "    pred = torch.eye(10).to(model.device).index_select(dim=0, index=torch.argmax(logits, dim=1))\n",
    "    batch_size = digit_caps_output.shape[0]\n",
    "    reconstruction = model.decoder((digit_caps_output * pred.unsqueeze(2)).contiguous().view(batch_size, -1))\n",
    "    image_size = (28, 28)\n",
    "    image = reconstruction.view(*image_size).cpu().detach().numpy()\n",
    "    plt.imshow(image, cmap='gray')\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "    return reconstruction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c3c9f57a-3820-457a-bc04-0e002b1a3536",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index_new = 8 # 28 18 10 13 15 16 19 9 7 8\n",
    "visual_images(global_model, index_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e964dd0a-e525-4a7c-ae41-83e5f0f6556e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------\n",
      "The size of primary caps is torch.Size([1, 1152, 8])\n",
      "The size of digit caps is torch.Size([1, 10, 16])\n",
      "--------------------\n",
      "The size of c is torch.Size([1, 10, 1152, 1])\n",
      "The size of b is torch.Size([1, 10, 1152, 1])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "primary_caps_output_new, digit_caps_output_new, c_new, b_new = visual_images2(global_model, index_new)\n",
    "visualize_digit_caps_output(digit_caps_output_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2979e514-7c8e-4e68-9949-206f034bbe04",
   "metadata": {},
   "outputs": [],
   "source": [
    "digit_index = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a245d55e-8dcf-479c-8d82-3716ca8063c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices of primary capsules with coupling coefficients above threshold: tensor([], device='cuda:1', dtype=torch.int64)\n",
      "Top N primary capsules indices: tensor([655, 195, 446, 152, 924, 468, 164, 999, 495, 873], device='cuda:1')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_n_indices = visualize_top_n(c_new, digit_index, 10, 0.3)\n",
    "indices_list = [index.cpu().item() if index.is_cuda else index.item() for index in top_n_indices]\n",
    "reconstruction_new = reconstruct_image_with_removal_selected_capsules(global_model, primary_caps_output_new, indices_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "66b6cb7b-507d-4704-b8fd-a77ba5e288d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices of primary capsules with coupling coefficients above threshold: tensor([], device='cuda:1', dtype=torch.int64)\n",
      "Top N primary capsules indices: tensor([ 655,  195,  446,  152,  924,  468,  164,  999,  495,  873,  904, 1001,\n",
      "         597,  584,  756,  947,  118,  105,  785,  461,  170,  750,  699,  257,\n",
      "        1024,  185,  860,  492,  526, 1040], device='cuda:1')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_n_indices = visualize_top_n(c_new, digit_index, 30, 0.3)\n",
    "indices_list = [index.cpu().item() if index.is_cuda else index.item() for index in top_n_indices]\n",
    "reconstruction_new = reconstruct_image_with_removal_selected_capsules(global_model, primary_caps_output_new, indices_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "997fa66d-44c7-4988-ac66-edfa5723265c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices of primary capsules with coupling coefficients above threshold: tensor([], device='cuda:1', dtype=torch.int64)\n",
      "Top N primary capsules indices: tensor([ 655,  195,  446,  152,  924,  468,  164,  999,  495,  873,  904, 1001,\n",
      "         597,  584,  756,  947,  118,  105,  785,  461,  170,  750,  699,  257,\n",
      "        1024,  185,  860,  492,  526, 1040,  448,  943,  587,  588, 1015,  783,\n",
      "         973,  959,  264,  357,  688,  580,  691,  624,  969,  601,  893,  398,\n",
      "         428,  701], device='cuda:1')\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAADvCAYAAADFCIRXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAABDwUlEQVR4nO3dd1xT1/8/8FdQkiDIkiEogooKynIi0koVFK2i1lG1reDWihO1/VoH7lUL1lFXFeuqq67WiYhalTpQXHWBA+sArVUEB0rO7w9/5GNMgESDifp6Ph551Hvuufe+b3JCeXPGlQghBIiIiIiIiKhAJoYOgIiIiIiIyNgxcSIiIiIiIioCEyciIiIiIqIiMHEiIiIiIiIqAhMnIiIiIiKiIjBxIiIiIiIiKgITJyIiIiIioiIwcSIiIiIiIioCEyciIiIiIqIiMHEiIiomV69ehUQiwdKlSw0dChXgk08+wSeffPJWr/n8+XN88803cHFxgYmJCdq0afNWr68NNzc3dO3a9bWONcR7aswkEgnGjh1r6DCISA+YOBGRViQSiVavvXv3GiyWqVOnqtW9ceMGPv/8c1hbW8PS0hKtW7fG5cuXtbqOm5ubyvkdHBzw8ccfY+PGjfq+pXdOVlYWxo0bB19fX1hYWMDMzAxeXl749ttvcfPmTUOHZ9SWLFmC77//Hu3bt8cvv/yCIUOGFOv1PvnkE2UbNjExgaWlJapVq4YuXbogPj6+WK8NADdv3sTYsWORkpKi03FpaWno06cPKlWqBLlcDktLSwQGBuLHH3/E48ePiyfYd8DLn+fLr2bNmhk6NKL3XklDB0BE74bly5erbC9btgzx8fFq5Z6enm8lniZNmiA8PFylrGbNmirb2dnZaNSoER48eIDvvvsOpqamiI2NRVBQEFJSUlCmTJkir+Pn54ehQ4cCePEL4IIFC9C2bVvMmzcPffv2LfRYV1dXPH78GKampjrenXG7fPkyQkJCkJ6ejg4dOqB3796QSqU4deoUFi9ejI0bN+LixYuGDtNo7dmzB+XKlUNsbOxbu2b58uUxZcoUAEBOTg5SU1OxYcMGrFixAp9//jlWrFih0k4vXLgAE5PX+9vqrl27VLZv3ryJcePGwc3NDX5+flqdY+vWrejQoQNkMhnCw8Ph5eWF3NxcHDhwAMOHD8fZs2excOHC14rvffDy55nP2dnZQNEQfTiYOBGRVr766iuV7b/++gvx8fFq5W9L1apVi7z2Tz/9hEuXLuHIkSOoW7cuAKB58+bw8vLCDz/8gMmTJxd5nXLlyqlcJzw8HO7u7oiNjS0wcXr+/DkUCgWkUinkcrkOd1W8njx5AqlU+tq/EAMv7q1t27bIyMjA3r178dFHH6nsnzRpEqZNm/amob7XMjMzYW1trbfzKRQK5ObmFtrWrKys1L4vU6dOxcCBA/HTTz/Bzc1N5XOTyWSvHY9UKn3tYwHgypUr6NSpE1xdXbFnzx44OTkp90VGRiI1NRVbt259o2u86zR9nkRU/DhUj4j0JicnB0OHDoWLiwtkMhmqVauGGTNmQAihUk8ikaB///5YuXIlqlWrBrlcjtq1a2P//v06Xe/x48d48uRJgfvXr1+PunXrKpMmAPDw8EBwcDDWrl2r2839f2XLloWnpyeuXLkC4H/zmGbMmIGZM2eicuXKkMlk+PvvvzXOceratSssLCyQnp6Oli1bwsLCAuXKlcPcuXMBAKdPn0bjxo1hbm4OV1dXrFq1SuX69+7dw7Bhw+Dt7Q0LCwtYWlqiefPmOHnypEq9vXv3QiKRYPXq1Rg1ahTKlSuHUqVKISUlBRKJRGNvx6FDhyCRSPDrr78WeP+//fYbTp48iZEjR6olTQBgaWmJSZMmKbf//PNPdOjQARUqVIBMJoOLiwuGDBmiNtQq/325fPkyQkNDYW5uDmdnZ4wfP16t/axevRq1a9dG6dKlYWlpCW9vb/z444/K/WPHjoVEIlGLbenSpZBIJLh69WqB9wcAT58+RXR0NNzd3ZUxf/PNN3j69KlKvfj4eHz00UewtraGhYUFqlWrhu+++67A8+a3h8TERJw9e1ZteOvrfH9q1KgBmUyGHTt2FHpPmpQoUQKzZs1C9erVMWfOHDx48EC5T9Mcp1OnTiEoKAhmZmYoX748Jk6ciLi4OLX39OU5Tnv37lV+/7p166a858Lm/U2fPh3Z2dlYvHixStKUz93dHYMGDVJux8XFoXHjxnBwcIBMJkP16tUxb948tePc3NzQsmVL7Nq1C35+fpDL5ahevTo2bNigUu/Zs2cYN24cqlSpArlcjjJlyuCjjz5SGdZY0Dyurl27ws3NrcB7y3fjxg10794djo6OkMlkqFGjBpYsWVLkcS97/vw5srOzdTqGiN4Me5yISC+EEGjVqhUSExPRo0cP+Pn5YefOnRg+fDhu3Lih9ov6vn37sGbNGgwcOBAymQw//fQTmjVrhiNHjsDLy6vI6y1duhQ//fQThBDw9PTEqFGj8MUXXyj3KxQKnDp1Ct27d1c7tl69eti1axcePnyI0qVL63Sfz549w/Xr19WG+cXFxeHJkyfo3bs3ZDIZbG1toVAoNJ4jLy8PzZs3R8OGDTF9+nSsXLkS/fv3h7m5OUaOHIkvv/wSbdu2xfz58xEeHo6AgABUrFgRwIthcps2bUKHDh1QsWJFZGRkYMGCBQgKCsLff/+tNlxnwoQJkEqlGDZsGJ4+fQoPDw8EBgZi5cqVanNrVq5cidKlS6N169YF3v+WLVsAAF26dNHq/Vq3bh0ePXqEr7/+GmXKlMGRI0cwe/Zs/PPPP1i3bp3a+9KsWTPUr18f06dPx44dOxAdHY3nz59j/PjxAF4kK507d0ZwcLCyh+TcuXM4ePCgyi/Tr0uhUKBVq1Y4cOAAevfuDU9PT5w+fRqxsbG4ePEiNm3aBAA4e/YsWrZsCR8fH4wfPx4ymQypqak4ePBggee2t7fH8uXLMWnSJGRnZyuHWnl6eur8/dmzZw/Wrl2L/v37w87OTqtf1jUpUaIEOnfujNGjR+PAgQNo0aKFxno3btxAo0aNIJFIMGLECJibm+Pnn38usmfK09MT48ePx5gxY9C7d298/PHHAIAGDRoUeMzvv/+OSpUqFVrnZfPmzUONGjXQqlUrlCxZEr///jv69esHhUKByMhIlbqXLl1Cx44d0bdvX0RERCAuLg4dOnTAjh070KRJEwAvEu8pU6agZ8+eqFevHrKysnDs2DEcP35cWedNZGRkoH79+soE2N7eHtu3b0ePHj2QlZWFwYMHF3mOixcvwtzcHLm5uXB0dESvXr0wZsyY925YMJHREUREryEyMlK8/CNk06ZNAoCYOHGiSr327dsLiUQiUlNTlWUABABx7NgxZdm1a9eEXC4Xn332WZHXbtCggZg5c6bYvHmzmDdvnvDy8hIAxE8//aSsc+fOHQFAjB8/Xu34uXPnCgDi/PnzhV7H1dVVNG3aVNy5c0fcuXNHnDx5UnTq1EkAEAMGDBBCCHHlyhUBQFhaWorMzEyV4/P3xcXFKcsiIiIEADF58mRl2X///SfMzMyERCIRq1evVpafP39eABDR0dHKsidPnoi8vDy168hkMpV7TUxMFABEpUqVxKNHj1TqL1iwQAAQ586dU5bl5uYKOzs7ERERUeh7UrNmTWFlZVVonZe9em0hhJgyZYqQSCTi2rVryrL89yX/fRVCCIVCIVq0aCGkUqm4c+eOEEKIQYMGCUtLS/H8+fMCrxkdHS00/e8tLi5OABBXrlxRlgUFBYmgoCDl9vLly4WJiYn4888/VY6dP3++ACAOHjwohBAiNjZWAFDGpYugoCBRo0YNlTJdvz8mJibi7Nmzr329l23cuFEAED/++KOyzNXVVaUtDBgwQEgkEnHixAll2b///itsbW2LfE+PHj2q9j0oyIMHDwQA0bp1ay3u7AVNbSw0NFRUqlRJpczV1VUAEL/99pvK9ZycnETNmjWVZb6+vqJFixaFXvPVe8wXEREhXF1dVcpe/Q736NFDODk5ibt376rU69Spk7CystJ4Py/r3r27GDt2rPjtt9/EsmXLRKtWrQQA8fnnnxd6HBG9OQ7VIyK92LZtG0qUKIGBAweqlA8dOhRCCGzfvl2lPCAgALVr11ZuV6hQAa1bt8bOnTuRl5dX6LXyexdatWqFvn37Ijk5GV5eXvjuu++UQ8Dy/6vpL+L5c0G0WZlr165dsLe3h729PXx9fbFu3Tp06dJFbR5Pu3btYG9vX+T58vXs2VP5b2tra1SrVg3m5ub4/PPPleXVqlWDtbW1yiqAMplMOUcpLy8P//77r3KY2PHjx9WuExERATMzM5Wyzz//HHK5HCtXrlSW7dy5E3fv3i1y3kRWVpZOvXQvXzsnJwd3795FgwYNIITAiRMn1Or3799f+e/8v8jn5uZi9+7dAF68Vzk5OcW2Gty6devg6ekJDw8P3L17V/lq3LgxACAxMVEZBwBs3ry5wJ5FXej6/QkKCkL16tXf+LoAYGFhAQB4+PBhgXV27NiBgIAAlcUdbG1t8eWXX+olhnxZWVkA8Npt7MGDB7h79y6CgoJw+fJlleGHwIsFFD777DPltqWlJcLDw3HixAncvn0bwIvP9uzZs7h06dKb3IpGQgj89ttvCAsLgxBCpY2FhobiwYMHGr/HL1u8eDGio6PRtm1bdOnSBZs3b0avXr2wdu1a/PXXX3qPmYj+h4kTEenFtWvX4OzsrPYLT/4qe9euXVMpr1Klito5qlatikePHuHOnTs6XVsqlaJ///64f/8+kpOTAfzvl6lX56UAUM6LejWh0MTf3x/x8fHYvXs3Dh06hLt372LZsmVqx+YPpdOGXC5XS7KsrKxQvnx5tbk5VlZW+O+//5TbCoUCsbGxqFKlCmQyGezs7GBvb49Tp06p/ZJYUFzW1tYICwtTmT+1cuVKlCtXTpkgFMTS0rLQX7BflZ6ejq5du8LW1hYWFhawt7dHUFAQAKjFa2JigkqVKqmUVa1aFQCUc2j69euHqlWronnz5ihfvjy6d+/+WvN7CnLp0iWcPXtWmSznv/LjyMzMBAB07NgRgYGB6NmzJxwdHdGpUyesXbv2tZMoXb8/urS3ouTPkyksWbl27Rrc3d3VyjWVvQlLS0sAhSdxrzp48CBCQkJgbm4Oa2tr2NvbK+eavdrG3N3d1b5jr7ax8ePH4/79+6hatSq8vb0xfPhwnDp16nVvScWdO3dw//59LFy4UK2NdevWDcD/2pgu8lf+zP8DAxEVD85xIqL3gouLC4AXiycAL/4aLpPJcOvWLbW6+WXaLN9rZ2eHkJCQIutpk4TlK1GihE7l4qXFASZPnozRo0eje/fumDBhAmxtbWFiYoLBgwdr/KW9oLjCw8Oxbt06HDp0CN7e3tiyZQv69etX5Ip7Hh4eOHHiBK5fv658zwuSl5eHJk2a4N69e/j222/h4eEBc3Nz3LhxA127dn2tJMPBwQEpKSnYuXMntm/fju3btyMuLg7h4eH45ZdfAEDjwhD58RRFoVDA29sbMTExGvfn37OZmRn279+PxMREbN26FTt27MCaNWvQuHFj7Nq1q8DPUl90aW9FOXPmDAD9J0Gvw9LSEs7OzsqYipKWlobg4GB4eHggJiYGLi4ukEql2LZtG2JjY1+rjTVs2BBpaWnYvHkzdu3ahZ9//hmxsbGYP3++sqdYIpGoLdoBFN3G8uP56quvEBERobGOj4+PzjG/+vOPiIoHEyci0gtXV1fs3r1bbcGF8+fPK/e/TNMwmIsXL6JUqVI6DXnLlz+cLf9YExMTeHt749ixY2p1Dx8+jEqVKum8MIQxWL9+PRo1aoTFixerlN+/fx92dnZan6dZs2awt7fHypUr4e/vj0ePHmm14ENYWBh+/fVXrFixAiNGjCi07unTp3Hx4kX88ssvKs/cKmiYnUKhwOXLl5U9AACUz4N6efEDqVSKsLAwhIWFQaFQoF+/fliwYAFGjx4Nd3d32NjYAHjxnry87PervTaaVK5cGSdPnkRwcHCBCVg+ExMTBAcHIzg4GDExMZg8eTJGjhyJxMRErZLtl+n6/dGXvLw8rFq1CqVKldK4SuLL8aWmpqqVayp7VVHv46tatmyJhQsXIikpCQEBAYXW/f333/H06VNs2bIFFSpUUJbnD6nUFK8QQiUmTW3M1tYW3bp1Q7du3ZCdnY2GDRti7NixysTJxsZG44O0i2pj9vb2KF26NPLy8nRuI4V59ecfERUPDtUjIr349NNPkZeXhzlz5qiUx8bGQiKRoHnz5irlSUlJKmP5r1+/js2bN6Np06aF/rVe0zC+hw8fYubMmbCzs1OZN9W+fXscPXpUJXm6cOEC9uzZgw4dOuh8j8agRIkSan/pXrduHW7cuKHTeUqWLInOnTtj7dq1WLp0Kby9vbX6S3f79u3h7e2NSZMmISkpSW3/w4cPMXLkSGWsgGqPmRBCZenwV73cfoQQmDNnDkxNTREcHAwA+Pfff1Xqm5iYKOPOH5ZZuXJlAFBZ3j4nJ0fZI1WYzz//HDdu3MCiRYvU9j1+/Bg5OTkANP9lP3/+j6bhoUXR9fujD3l5eRg4cCDOnTuHgQMHKofJaRIaGoqkpCSkpKQoy+7du6cyT64g5ubmAF4kstr45ptvYG5ujp49eyIjI0Ntf1pamrINaWpjDx48QFxcnMZz37x5Exs3blRuZ2VlYdmyZfDz80PZsmUBqLcxCwsLuLu7q3yulStXxvnz51V+Hp08ebLQVRXz423Xrh1+++03jb1qRQ1TzsrKUmtfQghMnDgRwIvPiYiKD3uciEgvwsLC0KhRI4wcORJXr16Fr68vdu3ahc2bN2Pw4MHKX2bzeXl5ITQ0VGU5cgAYN25codeZO3cuNm3ahLCwMFSoUAG3bt3CkiVLkJ6ejuXLl6s8fLNfv35YtGgRWrRogWHDhsHU1BQxMTFwdHRUzgl417Rs2RLjx49Ht27d0KBBA5w+fRorV65UmxukjfDwcMyaNQuJiYlaP7TW1NQUGzZsQEhICBo2bIjPP/8cgYGBMDU1xdmzZ7Fq1SrY2Nhg0qRJ8PDwQOXKlTFs2DDcuHEDlpaW+O2331TmbL1MLpdjx44diIiIgL+/P7Zv346tW7fiu+++U/4lvWfPnrh37x4aN26M8uXL49q1a5g9ezb8/PyU84GaNm2KChUqoEePHhg+fDhKlCiBJUuWwN7eHunp6YXeX5cuXbB27Vr07dsXiYmJCAwMRF5eHs6fP4+1a9di586dqFOnDsaPH4/9+/ejRYsWcHV1RWZmJn766SeUL1++0J6bguj6/dHVgwcPsGLFCgDAo0ePkJqaig0bNiAtLQ2dOnXChAkTCj3+m2++wYoVK9CkSRMMGDBAuRx5hQoVcO/evUJ7lSpXrgxra2vMnz8fpUuXhrm5Ofz9/Qucp1W5cmWsWrUKHTt2hKenJ8LDw+Hl5YXc3FwcOnQI69atUz5jqmnTpsoeyD59+iA7OxuLFi2Cg4ODxmG6VatWRY8ePXD06FE4OjpiyZIlyMjIUEm0qlevjk8++QS1a9eGra0tjh07hvXr16ssXNK9e3fExMQgNDQUPXr0QGZmJubPn48aNWooF7goyNSpU5GYmAh/f3/06tUL1atXx71793D8+HHs3r270OF2x48fR+fOndG5c2e4u7vj8ePH2LhxIw4ePIjevXujVq1ahV6biN6QIZbyI6J336vLkQshxMOHD8WQIUOEs7OzMDU1FVWqVBHff/+9UCgUKvUAiMjISLFixQpRpUoVIZPJRM2aNUViYmKR1921a5do0qSJKFu2rDA1NRXW1taiadOmIiEhQWP969evi/bt2wtLS0thYWEhWrZsKS5duqTVPbq6uha5LHH+kuPff/99gfteXY7c3NxcrW5BS0a/GsOTJ0/E0KFDhZOTkzAzMxOBgYEiKSlJbXnk/OXI161bV2j8NWrUECYmJuKff/4ptN6r/vvvPzFmzBjh7e0tSpUqJeRyufDy8hIjRowQt27dUtb7+++/RUhIiLCwsBB2dnaiV69e4uTJkwW+L2lpaaJp06aiVKlSwtHRUURHR6ssv75+/XrRtGlT4eDgIKRSqahQoYLo06ePyjWFECI5OVn4+/sr68TExGi1HLkQL5ZmnzZtmqhRo4aQyWTCxsZG1K5dW4wbN048ePBACCFEQkKCaN26tXB2dhZSqVQ4OzuLzp07i4sXLxb53hX0Wev6/dFWUFCQ8hEAAISFhYWoUqWK+Oqrr8SuXbs0HvPqcuRCCHHixAnx8ccfC5lMJsqXLy+mTJkiZs2aJQCI27dvq1zv1fd08+bNonr16qJkyZJaL01+8eJF0atXL+Hm5iakUqkoXbq0CAwMFLNnzxZPnjxR1tuyZYvw8fERcrlcuLm5iWnTpoklS5aofdb536WdO3cKHx8fIZPJhIeHh9p3ZOLEiaJevXrC2tpamJmZCQ8PDzFp0iSRm5urUm/FihWiUqVKQiqVCj8/P7Fz506tliMXQoiMjAwRGRkpXFxchKmpqShbtqwIDg4WCxcuLPQ9uXz5sujQoYNwc3MTcrlclCpVStSuXVvMnz9frZ0Qkf5JhNAwu5GIqBhJJBJERkaqDUuit69mzZqwtbVFQkKCQePo2rUr1q9fr1zhjd4NgwcPxoIFC5CdnV3sC2K8KTc3N3h5eeGPP/4wdChE9I7iHCciog/UsWPHkJKSorJwA1FBXn3u2b///ovly5fjo48+MvqkiYhIHzjHiYjoA3PmzBkkJyfjhx9+gJOTEzp27GjokOgdEBAQgE8++QSenp7IyMjA4sWLkZWVhdGjRxs6NCKit4KJExHRB2b9+vUYP348qlWrhl9//RVyudzQIdE74NNPP8X69euxcOFCSCQS1KpVC4sXL0bDhg0NHRoR0VvBOU5ERERERERF4BwnIiIiIiKiIjBxIiIiIiIiKsIHN8dJoVDg5s2bKF26dKEP7CMiIiIiovebEAIPHz6Es7MzTEwK71P64BKnmzdvwsXFxdBhEBERERGRkbh+/TrKly9faJ0PLnEqXbo0gBdvjqWlpYGjISIiIiIiQ8nKyoKLi4syRyjMB5c45Q/Ps7S0ZOJERERERERaTeHh4hBERERERERFYOJERERERERUBCZORERERERERWDiREREREREVIQPbnEIY+T2f1u1rnt1aotijISIiIiIiDTRuccpPT0dQgi1ciEE0tPT9RIUERERERGRMdE5capYsSLu3LmjVn7v3j1UrFhRL0EREREREREZE50TJyGExnXOs7OzIZfL9RIUERERERGRMdF6jlNUVBSAFw+HGj16NEqVKqXcl5eXh8OHD8PPz0/vARIRERERERma1onTiRMnALzocTp9+jSkUqlyn1Qqha+vL4YNG6b/CImIiIiIiAxM68QpMTERANCtWzf8+OOPsLS0LLagiIiIiIiIjInOy5HHxcUVRxxERERERERGS+fEKScnB1OnTkVCQgIyMzOhUChU9l++fFlvwRERERERERkDnROnnj17Yt++fejSpQucnJw0rrBHRERERET0PtE5cdq+fTu2bt2KwMDA4oiHiIiIiIjI6Oj8HCcbGxvY2toWRyxERERERERGSefEacKECRgzZgwePXpUHPEQEREREREZHZ2H6v3www9IS0uDo6Mj3NzcYGpqqrL/+PHjeguOiIiIiIjIGOicOLVp06YYwiAiIiIiIjJeOidO0dHRxREHERERERGR0dJ5jhMA3L9/Hz///DNGjBiBe/fuAXgxRO/GjRt6DY6IiIiIiMgY6NzjdOrUKYSEhMDKygpXr15Fr169YGtriw0bNiA9PR3Lli0rjjiJiIiIiIgMRucep6ioKHTt2hWXLl2CXC5Xln/66afYv3+/XoMjIiIiIiIyBjonTkePHkWfPn3UysuVK4fbt2/rJSgiIiIiIiJjonPiJJPJkJWVpVZ+8eJF2Nvb6yUoIiIiIiIiY6Jz4tSqVSuMHz8ez549AwBIJBKkp6fj22+/Rbt27fQeIBERERERkaHpnDj98MMPyM7OhoODAx4/foygoCC4u7ujdOnSmDRpUnHESEREREREZFA6r6pnZWWF+Ph4HDhwAKdOnUJ2djZq1aqFkJCQ4oiPiIiIiIjI4HROnPJ99NFH+Oijj/QZC+nI7f+2al336tQWxRgJEREREdH7TavEadasWejduzfkcjlmzZpVaN2BAwfqJTAqPky4iIiIiIh0o1XiFBsbiy+//BJyuRyxsbEF1pNIJEyciIiIiIjovaNV4nTlyhWN/yYiIiIiIvoQ6LyqHhERERER0YdG58SpXbt2mDZtmlr59OnT0aFDB70ERUREREREZEx0Tpz279+PTz/9VK28efPm2L9//2sFMXfuXLi5uUEul8Pf3x9HjhwpsO6iRYvw8ccfw8bGBjY2NggJCSm0PhERERER0ZvSOXHKzs6GVCpVKzc1NUVWVpbOAaxZswZRUVGIjo7G8ePH4evri9DQUGRmZmqsv3fvXnTu3BmJiYlISkqCi4sLmjZtihs3buh8bSIiIiIiIm3onDh5e3tjzZo1auWrV69G9erVdQ4gJiYGvXr1Qrdu3VC9enXMnz8fpUqVwpIlSzTWX7lyJfr16wc/Pz94eHjg559/hkKhQEJCgs7XJiIiIiIi0obOD8AdPXo02rZti7S0NDRu3BgAkJCQgF9//RXr1q3T6Vy5ublITk7GiBEjlGUmJiYICQlBUlKSVud49OgRnj17BltbW437nz59iqdPnyq3X6dXjF7g85+IiIiI6EOlc49TWFgYNm3ahNTUVPTr1w9Dhw7FP//8g927d6NNmzY6nevu3bvIy8uDo6OjSrmjoyNu376t1Tm+/fZbODs7IyQkROP+KVOmwMrKSvlycXHRKUYiIiIiIiKde5wAoEWLFmjRwvA9ClOnTsXq1auxd+9eyOVyjXVGjBiBqKgo5XZWVhaTp7eMPVVERERE9K57rcRJX+zs7FCiRAlkZGSolGdkZKBs2bKFHjtjxgxMnToVu3fvho+PT4H1ZDIZZDKZXuKlt0uXhAtg0kVERERExUeroXq2tra4e/cuAMDGxga2trYFvnQhlUpRu3ZtlYUd8hd6CAgIKPC46dOnY8KECdixYwfq1Kmj0zWJiIiIiIh0pVWPU2xsLEqXLg0AmDlzpl4DiIqKQkREBOrUqYN69eph5syZyMnJQbdu3QAA4eHhKFeuHKZMmQIAmDZtGsaMGYNVq1bBzc1NORfKwsICFhYWeo2NiIiIiIgI0DJxOnnyJNq3bw+ZTIaKFSuiQYMGKFlSP6P8OnbsiDt37mDMmDG4ffs2/Pz8sGPHDuWCEenp6TAx+V/H2Lx585Cbm4v27durnCc6Ohpjx47VS0xEREREREQv0yr7mT17Nr799luYm5ujUaNGuHXrFhwcHPQWRP/+/dG/f3+N+/bu3auyffXqVb1dl4iIiIiISBtaJU5ubm6YNWsWmjZtCiEEkpKSYGNjo7Fuw4YN9RogERERERGRoWmVOH3//ffo27cvpkyZAolEgs8++0xjPYlEgry8PL0GSEREREREZGhaJU5t2rRBmzZtkJ2dDUtLS1y4cEGvQ/WIiIiIiIiMmVbLkUdFRSEnJwcWFhZITExExYoVYWVlpfFFRERERET0vtF5cYjGjRvrfXEIIn16kwfn6nIsH7hLRERE9OHg4hBERERERERF4OIQRHrwuj1V7OEiIiIiejdwcQiidxATLiIiIqK3S6vEKd/Li0OULKnToURERERERO8snbOfoKAgpKWlIS4uDmlpafjxxx/h4OCA7du3o0KFCqhRo0ZxxElEevA2hhS+fOybLNRBREREZEx0Tpz27duH5s2bIzAwEPv378ekSZPg4OCAkydPYvHixVi/fn1xxElEHxjOGyMiIiJjonPi9H//93+YOHEioqKiULp0aWV548aNMWfOHL0GR0T0tjDhIiIiosLonDidPn0aq1atUit3cHDA3bt39RIUEdG7ggkXERHRh8FE1wOsra1x69YttfITJ06gXLlyegmKiIiIiIjImOjc49SpUyd8++23WLduHSQSCRQKBQ4ePIhhw4YhPDy8OGIkInrvsKeKiIjo3aJzj9PkyZPh4eEBFxcXZGdno3r16mjYsCEaNGiAUaNGFUeMREREREREBqVzj5NUKsWiRYswevRonDlzBtnZ2ahZsyaqVKlSHPEREREREREZ3Gs/xbZChQpwcXEBAEgkEr0FREREBeMztYiIiAxD56F6ALBs2TJ4e3vDzMwMZmZm8PHxwfLly/UdGxERERERkVHQuccpJiYGo0ePRv/+/REYGAgAOHDgAPr27Yu7d+9iyJAheg+SiIgM520/jJgLZxARkTHSOXGaPXs25s2bp7KCXqtWrVCjRg2MHTuWiRMRERkEEy4iIipOOidOt27dQoMGDdTKGzRooPH5TkRERMaM88aIiEgbOs9xcnd3x9q1a9XK16xZw5X1iIiIiIjovaRzj9O4cePQsWNH7N+/XznH6eDBg0hISNCYUBEREdH/sKeKiOjdpHPi1K5dOxw+fBixsbHYtGkTAMDT0xNHjhxBzZo19R0fERER/X+cx0VEZDiv9Ryn2rVrY8WKFfqOhYiIiIiIyChpnTjdvHkTMTExGDNmDCwtLVX2PXjwABMnTsSwYcPg6Oio9yCJiIjo9XFpeCKiN6d14hQTE4OsrCy1pAkArKys8PDhQ8TExGDatGl6DZCIiIjeLW8jUXv5WM4bI6K3QevEaceOHZg/f36B+8PDw9GrVy8mTkRERPTO4AOeiUhbWidOV65cQYUKFQrcX758eVy9elUfMRERERHRS4w5wXv1WKL3ldaJk5mZGa5evVpg8nT16lWYmZnpLTAiIiIiere8ScJlzMkhexsJ0CFx8vf3x/Lly9GwYUON+5ctW4Z69erpLTAiIiIiog8de/+Mh9aJ07Bhw9CkSRNYWVlh+PDhytXzMjIyMH36dCxduhS7du0qtkCJiIiIiEg771Lv37tC68SpUaNGmDt3LgYNGoTY2FhYWlpCIpHgwYMHMDU1xezZs9G4cePijJWIiIiIiMggdHoAbp8+fdCyZUusXbsWqampEEKgatWqaN++PcqXL19cMRIRERERERmUTokTAJQrVw5DhgwpjliIiIiIiIiMkomhAyAiIiIiIjJ2TJyIiIiIiIiKwMSJiIiIiIioCEyciIiIiIiIisDEiYiIiIiIqAg6r6pnY2MDiUSiVi6RSCCXy+Hu7o6uXbuiW7duegmQiIiIiIjI0HROnMaMGYNJkyahefPmqFevHgDgyJEj2LFjByIjI3HlyhV8/fXXeP78OXr16qX3gImIiIiIiN42nROnAwcOYOLEiejbt69K+YIFC7Br1y789ttv8PHxwaxZs5g4ERERERHRe0HnOU47d+5ESEiIWnlwcDB27twJAPj0009x+fLlN4+OiIiIiIjICOicONna2uL3339XK//9999ha2sLAMjJyUHp0qW1Ot/cuXPh5uYGuVwOf39/HDlypMC6Z8+eRbt27eDm5gaJRIKZM2fqGj4REREREZHOdB6qN3r0aHz99ddITExUznE6evQotm3bhvnz5wMA4uPjERQUVOS51qxZg6ioKMyfPx/+/v6YOXMmQkNDceHCBTg4OKjVf/ToESpVqoQOHTpgyJAhuoZORERERET0WnROnHr16oXq1atjzpw52LBhAwCgWrVq2LdvHxo0aAAAGDp0qFbniomJQa9evZQr8M2fPx9bt27FkiVL8H//939q9evWrYu6desCgMb9RERERERExUHnxAkAAgMDERgY+EYXzs3NRXJyMkaMGKEsMzExQUhICJKSkt7o3C97+vQpnj59qtzOysrS27mJiIiIiOjD8FqJk0KhQGpqKjIzM6FQKFT2NWzYUKtz3L17F3l5eXB0dFQpd3R0xPnz518nLI2mTJmCcePG6e18RERERET04dE5cfrrr7/wxRdf4Nq1axBCqOyTSCTIy8vTW3D6MGLECERFRSm3s7Ky4OLiYsCIiIiIiIjoXaNz4tS3b1/UqVMHW7duhZOTEyQSyWtd2M7ODiVKlEBGRoZKeUZGBsqWLfta59REJpNBJpPp7XxERERERPTh0Xk58kuXLmHy5Mnw9PSEtbU1rKysVF7akkqlqF27NhISEpRlCoUCCQkJCAgI0DUsIiIiIiKiYqNzj5O/vz9SU1Ph7u7+xhePiopCREQE6tSpg3r16mHmzJnIyclRrrIXHh6OcuXKYcqUKQBeLCjx999/K/9948YNpKSkwMLCQi/xEBERERERaaJz4jRgwAAMHToUt2/fhre3N0xNTVX2+/j4aH2ujh074s6dOxgzZgxu374NPz8/7NixQ7lgRHp6OkxM/tcpdvPmTdSsWVO5PWPGDMyYMQNBQUHYu3evrrdCRERERESkFZ0Tp3bt2gEAunfvriyTSCQQQrzW4hD9+/dH//79Ne57NRlyc3NTW5CCiIiIiIiouOmcOF25cqU44iAiIiIiIjJaOidOrq6uxREHERERERGR0dIqcdqyZQuaN28OU1NTbNmypdC6rVq10ktgRERERERExkKrxKlNmza4ffs2HBwc0KZNmwLrGeMDcImIiIiIiN6UVomTQqHQ+G8iIiIiIqIPgc4PwCUiIiIiIvrQaNXjNGvWLK1POHDgwNcOhoiIiIiIyBhplTjFxsZqdTKJRMLEiYiIiIiI3jtaJU58dhMREREREX3I3miOkxACQgh9xUJERERERGSUXitxWrx4Mby8vCCXyyGXy+Hl5YWff/5Z37EREREREREZBa2G6r1szJgxiImJwYABAxAQEAAASEpKwpAhQ5Ceno7x48frPUgiIiIiIiJD0jlxmjdvHhYtWoTOnTsry1q1agUfHx8MGDCAiRMREREREb13dB6q9+zZM9SpU0etvHbt2nj+/LlegiIiIiIiIjImOidOXbp0wbx589TKFy5ciC+//FIvQRERERERERkTnYfqAS8Wh9i1axfq168PADh8+DDS09MRHh6OqKgoZb2YmBj9RElERERERGRAOidOZ86cQa1atQAAaWlpAAA7OzvY2dnhzJkzynoSiURPIRIRERERERmWzolTYmJiccRBRERERERktN7oAbhEREREREQfAp17nBo1alToMLw9e/a8UUBERERERETGRufEyc/PT2X72bNnSElJwZkzZxAREaGvuIiIiIiIiIyGzolTbGysxvKxY8ciOzv7jQMiIiIiIiIyNnqb4/TVV19hyZIl+jodERERERGR0dBb4pSUlAS5XK6v0xERERERERkNnYfqtW3bVmVbCIFbt27h2LFjGD16tN4CIyIiIiIiMhY6J05WVlYq2yYmJqhWrRrGjx+Ppk2b6i0wIiIiIiIiY6Fz4hQXF1cccRARERERERktnROnfMnJyTh37hwAoEaNGqhZs6begiIiIiIiIjImOidOmZmZ6NSpE/bu3Qtra2sAwP3799GoUSOsXr0a9vb2+o6RiIiIiIjIoHReVW/AgAF4+PAhzp49i3v37uHevXs4c+YMsrKyMHDgwOKIkYiIiIiIyKB07nHasWMHdu/eDU9PT2VZ9erVMXfuXC4OQURERERE7yWde5wUCgVMTU3Vyk1NTaFQKPQSFBERERERkTHROXFq3LgxBg0ahJs3byrLbty4gSFDhiA4OFivwRERERERERkDnROnOXPmICsrC25ubqhcuTIqV66MihUrIisrC7Nnzy6OGImIiIiIiAxK5zlOLi4uOH78OHbv3o3z588DADw9PRESEqL34IiIiIiIiIzBaz3HSSKRoEmTJmjSpIm+4yEiIiIiIjI6Wg/V27NnD6pXr46srCy1fQ8ePECNGjXw559/6jU4IiIiIiIiY6B14jRz5kz06tULlpaWavusrKzQp08fxMTE6DU4IiIiIiIiY6B14nTy5Ek0a9aswP1NmzZFcnKyXoIiIiIiIiIyJlonThkZGRqf35SvZMmSuHPnjl6CIiIiIiIiMiZaJ07lypXDmTNnCtx/6tQpODk56SUoIiIiIiIiY6J14vTpp59i9OjRePLkidq+x48fIzo6Gi1bttRrcERERERERMZA6+XIR40ahQ0bNqBq1aro378/qlWrBgA4f/485s6di7y8PIwcObLYAiUiIiIiIjIUrRMnR0dHHDp0CF9//TVGjBgBIQSAF890Cg0Nxdy5c+Ho6FhsgRIRERERERmKTg/AdXV1xbZt2/Dff/8hNTUVQghUqVIFNjY2xRUfERERERGRwemUOOWzsbFB3bp19R0LERERERGRUdJ6cYjiNHfuXLi5uUEul8Pf3x9HjhwptP66devg4eEBuVwOb29vbNu27S1FSkREREREHyKDJ05r1qxBVFQUoqOjcfz4cfj6+iI0NBSZmZka6x86dAidO3dGjx49cOLECbRp0wZt2rQpdKl0IiIiIiKiN2HwxCkmJga9evVCt27dUL16dcyfPx+lSpXCkiVLNNb/8ccf0axZMwwfPhyenp6YMGECatWqhTlz5rzlyImIiIiI6EPxWnOc9CU3NxfJyckYMWKEsszExAQhISFISkrSeExSUhKioqJUykJDQ7Fp0yaN9Z8+fYqnT58qtx88eAAAyMrKesPo9Ufx9JHWdV+Om8dpPvZ1j9P1WB5X9LH8LAx73MvH8rPQz3EvH8vPwrDHvXws31PDHvfysfwsDHvcy8e+S5+FIeXHkb9ieKGEAd24cUMAEIcOHVIpHz58uKhXr57GY0xNTcWqVatUyubOnSscHBw01o+OjhYA+OKLL7744osvvvjiiy++NL6uX79eZO5i0B6nt2HEiBEqPVQKhQL37t1DmTJlIJFIDBhZwbKysuDi4oLr16/D0tLS0OHQO4LthnTFNkOvg+2GdMU2Q6/jbbUbIQQePnwIZ2fnIusaNHGys7NDiRIlkJGRoVKekZGBsmXLajymbNmyOtWXyWSQyWQqZdbW1q8f9FtkaWnJHzCkM7Yb0hXbDL0OthvSFdsMvY630W6srKy0qmfQxSGkUilq166NhIQEZZlCoUBCQgICAgI0HhMQEKBSHwDi4+MLrE9ERERERPSmDD5ULyoqChEREahTpw7q1auHmTNnIicnB926dQMAhIeHo1y5cpgyZQoAYNCgQQgKCsIPP/yAFi1aYPXq1Th27BgWLlxoyNsgIiIiIqL3mMETp44dO+LOnTsYM2YMbt++DT8/P+zYsQOOjo4AgPT0dJiY/K9jrEGDBli1ahVGjRqF7777DlWqVMGmTZvg5eVlqFvQO5lMhujoaLUhhkSFYbshXbHN0OtguyFdsc3Q6zDGdiMRQpu194iIiIiIiD5cBn8ALhERERERkbFj4kRERERERFQEJk5ERERERERFYOJERERERERUBCZORmju3Llwc3ODXC6Hv78/jhw5YuiQyEjs378fYWFhcHZ2hkQiwaZNm1T2CyEwZswYODk5wczMDCEhIbh06ZJhgiWjMGXKFNStWxelS5eGg4MD2rRpgwsXLqjUefLkCSIjI1GmTBlYWFigXbt2ag8apw/LvHnz4OPjo3zwZEBAALZv367czzZDRZk6dSokEgkGDx6sLGO7oVeNHTsWEolE5eXh4aHcb2xthomTkVmzZg2ioqIQHR2N48ePw9fXF6GhocjMzDR0aGQEcnJy4Ovri7lz52rcP336dMyaNQvz58/H4cOHYW5ujtDQUDx58uQtR0rGYt++fYiMjMRff/2F+Ph4PHv2DE2bNkVOTo6yzpAhQ/D7779j3bp12LdvH27evIm2bdsaMGoytPLly2Pq1KlITk7GsWPH0LhxY7Ru3Rpnz54FwDZDhTt69CgWLFgAHx8flXK2G9KkRo0auHXrlvJ14MAB5T6jazOCjEq9evVEZGSkcjsvL084OzuLKVOmGDAqMkYAxMaNG5XbCoVClC1bVnz//ffKsvv37wuZTCZ+/fVXA0RIxigzM1MAEPv27RNCvGgjpqamYt26dco6586dEwBEUlKSocIkI2RjYyN+/vlnthkq1MOHD0WVKlVEfHy8CAoKEoMGDRJC8GcNaRYdHS18fX017jPGNsMeJyOSm5uL5ORkhISEKMtMTEwQEhKCpKQkA0ZG74IrV67g9u3bKu3HysoK/v7+bD+k9ODBAwCAra0tACA5ORnPnj1TaTceHh6oUKEC2w0BAPLy8rB69Wrk5OQgICCAbYYKFRkZiRYtWqi0D4A/a6hgly5dgrOzMypVqoQvv/wS6enpAIyzzZQ0yFVJo7t37yIvLw+Ojo4q5Y6Ojjh//ryBoqJ3xe3btwFAY/vJ30cfNoVCgcGDByMwMBBeXl4AXrQbqVQKa2trlbpsN3T69GkEBATgyZMnsLCwwMaNG1G9enWkpKSwzZBGq1evxvHjx3H06FG1ffxZQ5r4+/tj6dKlqFatGm7duoVx48bh448/xpkzZ4yyzTBxIiL6QERGRuLMmTMq48eJClKtWjWkpKTgwYMHWL9+PSIiIrBv3z5Dh0VG6vr16xg0aBDi4+Mhl8sNHQ69I5o3b678t4+PD/z9/eHq6oq1a9fCzMzMgJFpxqF6RsTOzg4lSpRQWy0kIyMDZcuWNVBU9K7IbyNsP6RJ//798ccffyAxMRHly5dXlpctWxa5ubm4f/++Sn22G5JKpXB3d0ft2rUxZcoU+Pr64scff2SbIY2Sk5ORmZmJWrVqoWTJkihZsiT27duHWbNmoWTJknB0dGS7oSJZW1ujatWqSE1NNcqfNUycjIhUKkXt2rWRkJCgLFMoFEhISEBAQIABI6N3QcWKFVG2bFmV9pOVlYXDhw+z/XzAhBDo378/Nm7ciD179qBixYoq+2vXrg1TU1OVdnPhwgWkp6ez3ZAKhUKBp0+fss2QRsHBwTh9+jRSUlKUrzp16uDLL79U/pvthoqSnZ2NtLQ0ODk5GeXPGg7VMzJRUVGIiIhAnTp1UK9ePcycORM5OTno1q2boUMjI5CdnY3U1FTl9pUrV5CSkgJbW1tUqFABgwcPxsSJE1GlShVUrFgRo0ePhrOzM9q0aWO4oMmgIiMjsWrVKmzevBmlS5dWjgu3srKCmZkZrKys0KNHD0RFRcHW1haWlpYYMGAAAgICUL9+fQNHT4YyYsQING/eHBUqVMDDhw+xatUq7N27Fzt37mSbIY1Kly6tnDuZz9zcHGXKlFGWs93Qq4YNG4awsDC4urri5s2biI6ORokSJdC5c2fj/FljkLX8qFCzZ88WFSpUEFKpVNSrV0/89ddfhg6JjERiYqIAoPaKiIgQQrxYknz06NHC0dFRyGQyERwcLC5cuGDYoMmgNLUXACIuLk5Z5/Hjx6Jfv37CxsZGlCpVSnz22Wfi1q1bhguaDK579+7C1dVVSKVSYW9vL4KDg8WuXbuU+9lmSBsvL0cuBNsNqevYsaNwcnISUqlUlCtXTnTs2FGkpqYq9xtbm5EIIYRhUjYiIiIiIqJ3A+c4ERERERERFYGJExERERERURGYOBERERERERWBiRMREREREVERmDgREREREREVgYkTERERERFREZg4ERERERERFYGJExERERERURGYOBERfeDc3Nwwc+ZMQ4fxXlq6dCmsra0NHQYAfs5ERG+KiRMR0Xuia9eukEgkkEgkkEqlcHd3x/jx4/H8+fNCjzt69Ch69+79lqLUj9zcXEyfPh2+vr4oVaoU7OzsEBgYiLi4ODx79szQ4enV2LFj4efnZ+gwiIg+eCUNHQAREelPs2bNEBcXh6dPn2Lbtm2IjIyEqakpRowYoVY3NzcXUqkU9vb2Boj0f9d/neNCQ0Nx8uRJTJgwAYGBgbC0tMRff/2FGTNmoGbNmkw0iIhI79jjRET0HpHJZChbtixcXV3x9ddfIyQkBFu2bAHwokeqTZs2mDRpEpydnVGtWjUA6kO4JBIJFixYgJYtW6JUqVLw9PREUlISUlNT8cknn8Dc3BwNGjRAWlqa8pi0tDS0bt0ajo6OsLCwQN26dbF7926V2Nzc3DBhwgSEh4fD0tISvXv3RuPGjdG/f3+Venfu3IFUKkVCQoLGe5w5cyb279+PhIQEREZGws/PD5UqVcIXX3yBw4cPo0qVKgCAHTt24KOPPoK1tTXKlCmDli1bqsR89epVSCQSrF69Gg0aNIBcLoeXlxf27dunrPPff//hyy+/hL29PczMzFClShXExcUBAPbu3QuJRIL79+8r66ekpEAikeDq1asFfkabN29GrVq1IJfLUalSJYwbN67IXsGX5X+OM2bMgJOTE8qUKYPIyEiVnrbMzEyEhYXBzMwMFStWxMqVK9XOc//+ffTs2RP29vawtLRE48aNcfLkSQAvPoOyZcti8uTJyvqHDh0q9HMhInrfMXEiInqPmZmZITc3V7mdkJCACxcuID4+Hn/88UeBx+UnOCkpKfDw8MAXX3yBPn36YMSIETh27BiEECoJT3Z2Nj799FMkJCTgxIkTaNasGcLCwpCenq5y3hkzZsDX1xcnTpzA6NGj0bNnT6xatQpPnz5V1lmxYgXKlSuHxo0ba4xt5cqVCAkJQc2aNdX2mZqawtzcHACQk5ODqKgoHDt2DAkJCTAxMcFnn30GhUKhcszw4cMxdOhQnDhxAgEBAQgLC8O///4LABg9ejT+/vtvbN++HefOncO8efNgZ2dX4PtWlD///BPh4eEYNGgQ/v77byxYsABLly7FpEmTdDpPYmIi0tLSkJiYiF9++QVLly7F0qVLlfu7du2K69evIzExEevXr8dPP/2EzMxMlXN06NABmZmZ2L59O5KTk1GrVi0EBwfj3r17sLe3x5IlSzB27FgcO3YMDx8+RJcuXdC/f38EBwe/9v0TEb3TBBERvRciIiJE69athRBCKBQKER8fL2QymRg2bJhyv6Ojo3j69KnKca6uriI2Nla5DUCMGjVKuZ2UlCQAiMWLFyvLfv31VyGXywuNp0aNGmL27Nkq12nTpo1KncePHwsbGxuxZs0aZZmPj48YO3Zsgec1MzMTAwcOLPTamty5c0cAEKdPnxZCCHHlyhUBQEydOlVZ59mzZ6J8+fJi2rRpQgghwsLCRLdu3TSeLzExUQAQ//33n7LsxIkTAoC4cuWKEEKIuLg4YWVlpdwfHBwsJk+erHKe5cuXCycnpwLjjo6OFr6+vsrtiIgI4erqKp4/f64s69Chg+jYsaMQQogLFy4IAOLIkSPK/efOnRMAlJ/zn3/+KSwtLcWTJ09UrlW5cmWxYMEC5Xa/fv1E1apVxRdffCG8vb3V6hMRfUjY40RE9B75448/YGFhAblcjubNm6Njx44YO3ascr+3t7dW84p8fHyU/3Z0dFQe+3LZkydPkJWVBeBFj9OwYcPg6ekJa2trWFhY4Ny5c2o9TnXq1FHZlsvl6NKlC5YsWQIAOH78OM6cOYOuXbsWGJsQosj4AeDSpUvo3LkzKlWqBEtLS7i5uQGAWkwBAQHKf5csWRJ16tTBuXPnAABff/01Vq9eDT8/P3zzzTc4dOiQVtcuyMmTJzF+/HhYWFgoX7169cKtW7fw6NEjrc9To0YNlChRQrnt5OSk7FE6d+4cSpYsidq1ayv3e3h4qKzud/LkSWRnZ6NMmTIqsVy5ckVlOOOMGTPw/PlzrFu3DitXroRMJnuDuycierdxcQgiovdIo0aNMG/ePEilUjg7O6NkSdUf8/nD2Ipiamqq/LdEIimwLH/Y27BhwxAfH48ZM2bA3d0dZmZmaN++vcowwYKu37NnT/j5+eGff/5BXFwcGjduDFdX1wJjq1q1Ks6fP1/kPYSFhcHV1RWLFi2Cs7MzFAoFvLy81GIqTPPmzXHt2jVs27YN8fHxCA4ORmRkJGbMmAETkxd/e3w5kStqRb/s7GyMGzcObdu2Vdsnl8u1juvlzwJ48Xm8OgSxqDicnJywd+9etX0vJ1hpaWm4efMmFAoFrl69qpI8ExF9aJg4ERG9R8zNzeHu7v7Wr3vw4EF07doVn332GYAXv5gXtkDCy7y9vVGnTh0sWrQIq1atwpw5cwqt/8UXX+C7777DiRMn1OY5PXv2DLm5uXjy5AkuXLiARYsW4eOPPwYAHDhwQOP5/vrrLzRs2BAA8Pz5cyQnJ6vM37K3t0dERAQiIiLw8ccfY/jw4ZgxY4ZyNcJbt27BxsYGwIvFIQpTq1YtXLhwoVg/Iw8PD+V91K1bFwBw4cIFlUUsatWqhdu3b6NkyZLKnrhX5ebm4quvvkLHjh1RrVo19OzZE6dPn4aDg0OxxU5EZMw4VI+IiN5YlSpVsGHDBqSkpODkyZP44osvdOoB6dmzJ6ZOnQohhDL5KsjgwYMRGBiI4OBgzJ07FydPnsTly5exdu1a1K9fH5cuXYKNjQ3KlCmDhQsXIjU1FXv27EFUVJTG882dOxcbN27E+fPnERkZif/++w/du3cHAIwZMwabN29Gamoqzp49iz/++AOenp4AAHd3d7i4uGDs2LG4dOkStm7dih9++KHQ2MeMGYNly5Zh3LhxOHv2LM6dO4fVq1dj1KhRWr9XRalWrRqaNWuGPn364PDhw0hOTkbPnj1hZmamrBMSEoKAgAC0adMGu3btwtWrV3Ho0CGMHDkSx44dAwCMHDkSDx48wKxZs/Dtt9+iatWqyveFiOhDxMSJiIjeWExMDGxsbNCgQQOEhYUhNDQUtWrV0vr4zp07o2TJkujcuXORQ9ZkMhni4+PxzTffYMGCBahfvz7q1q2LWbNmYeDAgfDy8oKJiQlWr16N5ORkeHl5YciQIfj+++81nm/q1KmYOnUqfH19ceDAAWzZskW5cp5UKsWIESPg4+ODhg0bokSJEli9ejWAF8Plfv31V5w/fx4+Pj6YNm0aJk6cWGjsoaGh+OOPP7Br1y7UrVsX9evXR2xsbKFDE19HXFwcnJ2dERQUhLZt26J3794qPUUSiQTbtm1Dw4YN0a1bN1StWhWdOnXCtWvX4OjoiL1792LmzJlYvnw5LC0tYWJiguXLl+PPP//EvHnz9BorEdG7QiK0nWVLRERUTK5evYrKlSvj6NGjOiVcb3rNihUr4sSJE3xgLhERFYlznIiIyGCePXuGf//9F6NGjUL9+vXfWtJERESkKw7VIyIigzl48CCcnJxw9OhRzJ8/39DhEBERFYhD9YiIiIiIiIrAHiciIiIiIqIiMHEiIiIiIiIqAhMnIiIiIiKiIjBxIiIiIiIiKgITJyIiIiIioiIwcSIiIiIiIioCEyciIiIiIqIiMHEiIiIiIiIqwv8DD/UOLxTOuq4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_n_indices = visualize_top_n(c_new, digit_index, 50, 0.3)\n",
    "indices_list = [index.cpu().item() if index.is_cuda else index.item() for index in top_n_indices]\n",
    "reconstruction_new = reconstruct_image_with_removal_selected_capsules(global_model, primary_caps_output_new, indices_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4d73b7f2-c718-4289-a7cb-804991f64ecc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices of primary capsules with coupling coefficients above threshold: tensor([], device='cuda:1', dtype=torch.int64)\n",
      "Top N primary capsules indices: tensor([ 655,  195,  446,  152,  924,  468,  164,  999,  495,  873,  904, 1001,\n",
      "         597,  584,  756,  947,  118,  105,  785,  461,  170,  750,  699,  257,\n",
      "        1024,  185,  860,  492,  526, 1040,  448,  943,  587,  588, 1015,  783,\n",
      "         973,  959,  264,  357,  688,  580,  691,  624,  969,  601,  893,  398,\n",
      "         428,  701,  772,  746,   91,  594,  490, 1086,  628,   33,  149, 1143,\n",
      "          30,  935,  716,  618,  188,  438,  362,  566, 1075,  634,  366,   97,\n",
      "         484,  381,  987,  942,  205,  249,  950,   46,  954,  486,  620,  488,\n",
      "        1101,  845,  471,  536, 1004,  744, 1030,  864,  892,   72,  425,  522,\n",
      "         826,  599,  364,  839], device='cuda:1')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "top_n_indices = visualize_top_n(c_new, digit_index, 100, 0.3)\n",
    "indices_list = [index.cpu().item() if index.is_cuda else index.item() for index in top_n_indices]\n",
    "reconstruction_new = reconstruct_image_with_removal_selected_capsules(global_model, primary_caps_output_new, indices_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a14160f-2272-437e-be0c-fafcff0cfc3e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53cf4272-8928-474f-8367-24c82ef95b27",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Py38",
   "language": "python",
   "name": "xy_py38"
  },
  "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}