From 3396d4325ae2c680051cfdaf06b2d5771b61c345 Mon Sep 17 00:00:00 2001 From: Valerio Maggio Date: Fri, 24 May 2024 08:14:40 +0200 Subject: [PATCH] ML Model Threats Section --- 2-ml-models-attacks/.gitattributes | 2 - 2-ml-models-attacks/0-FSGM-Attack.ipynb | 3977 ---------------- 2-ml-models-attacks/1-FSGM-Attack.ipynb | 579 +++ 2-ml-models-attacks/1-MIA-Training.ipynb | 3644 --------------- .../2-MIA-Reconstruction.ipynb | 4161 ----------------- 2-ml-models-attacks/2-MIA-Training.ipynb | 430 ++ .../3-Introducing-OPACUS.ipynb | 3151 ------------- .../3-MIA-Reconstruction.ipynb | 393 ++ .../4-MIA-Training-OPACUS.ipynb | 3503 -------------- .../5-MIA-Reconstruction-OPACUS.ipynb | 3776 --------------- 2-ml-models-attacks/checkpoints/mlp_mia.pt | 3 - .../checkpoints/softmax_mia.pt | 3 - .../checkpoints/softmax_reg_opacus_test.pt | 3 - 13 files changed, 1402 insertions(+), 22223 deletions(-) delete mode 100644 2-ml-models-attacks/.gitattributes delete mode 100644 2-ml-models-attacks/0-FSGM-Attack.ipynb create mode 100644 2-ml-models-attacks/1-FSGM-Attack.ipynb delete mode 100644 2-ml-models-attacks/1-MIA-Training.ipynb delete mode 100644 2-ml-models-attacks/2-MIA-Reconstruction.ipynb create mode 100644 2-ml-models-attacks/2-MIA-Training.ipynb delete mode 100644 2-ml-models-attacks/3-Introducing-OPACUS.ipynb create mode 100644 2-ml-models-attacks/3-MIA-Reconstruction.ipynb delete mode 100644 2-ml-models-attacks/4-MIA-Training-OPACUS.ipynb delete mode 100644 2-ml-models-attacks/5-MIA-Reconstruction-OPACUS.ipynb delete mode 100644 2-ml-models-attacks/checkpoints/mlp_mia.pt delete mode 100644 2-ml-models-attacks/checkpoints/softmax_mia.pt delete mode 100644 2-ml-models-attacks/checkpoints/softmax_reg_opacus_test.pt diff --git a/2-ml-models-attacks/.gitattributes b/2-ml-models-attacks/.gitattributes deleted file mode 100644 index 5a14010..0000000 --- a/2-ml-models-attacks/.gitattributes +++ /dev/null @@ -1,2 +0,0 @@ -*.pt filter=lfs diff=lfs merge=lfs -text -checkpoints filter=lfs diff=lfs merge=lfs -text diff --git a/2-ml-models-attacks/0-FSGM-Attack.ipynb b/2-ml-models-attacks/0-FSGM-Attack.ipynb deleted file mode 100644 index 8799bb1..0000000 --- a/2-ml-models-attacks/0-FSGM-Attack.ipynb +++ /dev/null @@ -1,3977 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "
\n", - " The notebook is using\n", - " \n", - " no$\\TeX$book Jupyter Theme (release 2.0.1).\n", - "\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "##! SKIP THIS if on Google Colaboratory\n", - "%load_ext notexbook\n", - "%texify" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Fast Gradient Sign Attack" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This notebook showcases how to carry out a **Fast Gradient Sign Attack** (`FGSA`) to a pretrained model. \n", - "\n", - "**Note** This notebook has been adapted from the [FSGM Tutorial](https://pytorch.org/tutorials/beginner/fgsm_tutorial.html) by _Nathan Inkawhich_ `@inkawhich` available on the official [PyTorch Documentation](https://pytorch.org/docs/stable/index.html)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "(_from the original notebook_)\n", - "> This tutorial will raise your awareness to the security vulnerabilities \n", - "> of ML models, and will give insight into the hot topic of adversarial machine learning. \n", - "> \n", - "> You may be surprised to find that adding **imperceptible perturbations** to an image *can* cause \n", - "> drastically different model performance.\n", - "> `[...]`\n", - ">\n", - "> Specifically we will use one of the first and most popular attack methods, the _Fast Gradient Sign Attack_\n", - "> (`FGSM`), to fool an `MNIST` classifier.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Threats to Models\n", - "\n", - "There are several kinds of assumptions of the attacker’s knowledge, two of which are: **white-box** and **black-box**. \n", - "\n", - "- A *white-box* attack assumes the attacker has full knowledge and access to the model, including\n", - "architecture, inputs, outputs, and weights. \n", - "- A *black-box* attack assumes the attacker only has access to the inputs and outputs of the model, and knows nothing about the underlying architecture or weights. \n", - "\n", - "There are also several types of goals, including **misclassification** and\n", - "**source/target misclassification**. \n", - "\n", - "A goal of *misclassification* means the adversary only wants the output classification to be wrong but does\n", - "not care what the new classification is. \n", - "\n", - "A *source/target misclassification* means the adversary wants to alter an image that is originally of a specific source class so that it is classified as a specific target class." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Fast Gradient Sign Attack\n", - "\n", - "*Fast Gradient Sign Attack (FGSM)* and is described by _Goodfellow et. al._ in \n", - "[Explaining and Harnessing Adversarial Examples](https://arxiv.org/abs/1412.6572). \n", - "\n", - "The attack is remarkably powerful, and yet intuitive. \n", - "\n", - "It is designed to attack neural networks by leveraging the way they learn: **gradients**. \n", - "\n", - "The idea is simple: \n", - "\n", - "> rather than working to minimize the loss by adjusting the weights based on the backpropagated gradients,\n", - "> the attack **adjusts** the input data to maximize the loss based on the same backpropagated gradients. \n", - "\n", - "In other words, the attack uses the gradient of the loss w.r.t the input data, then adjusts the input data to maximize the loss.\n", - "\n", - "_(from the original paper)_\n", - "\n", - "![fgsm panda attack](https://pytorch.org/tutorials/_images/fgsm_panda_image.png)\n", - "\n", - "**TLDR;** Just perturbe the input data with some small change that would work in an **adversary** fashion (wrt. the optimisation process) that follows the **direction of the gradient** (i.e. $sign(\\nabla_{x} J(\\mathbf{\\theta}, \\mathbf{x}, y))$ )" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "import torch.optim as optim\n", - "\n", - "from torch.utils.data import DataLoader\n", - "from torchvision import datasets, transforms\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", - "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", - "from six.moves import urllib\n", - "\n", - "opener = urllib.request.build_opener()\n", - "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", - "urllib.request.install_opener(opener)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import os \n", - "\n", - "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/leriomaggio/Code/Python/Anaconda/ml_ai_program/tutorials/scipy_2023/ppml-tutorial/3-ml-models-attacks/../data\n" - ] - } - ], - "source": [ - "print(DATA_FOLDER)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Reproducibility Settings\n", - "\n", - "import numpy as np\n", - "\n", - "SEED = 123456\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "\n", - "if torch.cuda.is_available():\n", - " torch.cuda.manual_seed_all(SEED)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### `LeNet` Model" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# LeNet Model definition\n", - "class Net(nn.Module):\n", - " def __init__(self):\n", - " super(Net, self).__init__()\n", - " self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n", - " self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n", - " self.conv2_drop = nn.Dropout2d()\n", - " self.fc1 = nn.Linear(320, 50)\n", - " self.fc2 = nn.Linear(50, 10)\n", - "\n", - " def forward(self, x):\n", - " x = F.relu(F.max_pool2d(self.conv1(x), 2))\n", - " x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n", - " x = x.view(-1, 320)\n", - " x = F.relu(self.fc1(x))\n", - " x = F.dropout(x, training=self.training)\n", - " x = self.fc2(x)\n", - " return F.log_softmax(x, dim=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialise pre-trained model (and move it to available device)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "You will be using the mps device\n" - ] - } - ], - "source": [ - "if torch.cuda.is_available():\n", - " dev_name = \"cuda\"\n", - "elif torch.backends.mps.is_available():\n", - " dev_name = \"mps\"\n", - "else:\n", - " dev_name = \"cpu\"\n", - "\n", - "device = torch.device(dev_name)\n", - "print(f\"You will be using the {device} device\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'2.0.1'" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "torch.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# Uncomment this when running on Anaconda Notebooks\n", - "# !wget !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/lenet_mnist_model.pth" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Net(\n", - " (conv1): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))\n", - " (conv2): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))\n", - " (conv2_drop): Dropout2d(p=0.5, inplace=False)\n", - " (fc1): Linear(in_features=320, out_features=50, bias=True)\n", - " (fc2): Linear(in_features=50, out_features=10, bias=True)\n", - ")" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "PRETRAINED_MODEL_WEIGHTS = \"lenet_mnist_model.pth\"\n", - "\n", - "# Initialize the network\n", - "model = Net().to(device)\n", - "\n", - "# Load the pretrained model\n", - "model.load_state_dict(torch.load(PRETRAINED_MODEL_WEIGHTS, map_location=device))\n", - "\n", - "# Set the model in evaluation mode. In this case this is for the Dropout layers\n", - "model.eval()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Download MNIST Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# MNIST Test dataset and dataloader declaration\n", - "mnist_test = datasets.MNIST(root=DATA_FOLDER, train=False, download=True, transform=transforms.ToTensor())\n", - "test_loader = torch.utils.data.DataLoader(mnist_test, batch_size=1, shuffle=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Before the Attack\n", - "\n", - "Before carrying out the attack, let's see how well the model classify the digits in the test set" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "be906dcf1d904b32aee1093ceb6fd634", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10000 [00:00 torch.Tensor:\n", - " # Collect the element-wise sign of the data gradient\n", - " sign_data_grad = data_gradient.sign()\n", - " # Create the perturbed image by adjusting each pixel of the input image\n", - " perturbed_image = image + (epsilon * sign_data_grad)\n", - " # Adding clipping to maintain [0,1] range\n", - " perturbed_image = torch.clamp(perturbed_image, 0, 1) # normalise in [0, 1] to make it an actual image\n", - " # Return the perturbed image\n", - " return perturbed_image" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Last but not least: the **test function**" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "def test(model, device, loader, epsilon):\n", - " # from https://github.com/pytorch/tutorials/blob/master/beginner_source/fgsm_tutorial.py\n", - " \n", - " # Accuracy counter\n", - " correct = 0\n", - " adv_examples = []\n", - "\n", - " # Loop over all examples in test set\n", - " for data, target in tqdm(test_loader, desc=f\"Running Attack on Batches with ε={ε}\"):\n", - "\n", - " # Send the data and label to the device\n", - " data, target = data.to(device), target.to(device)\n", - "\n", - " # Set requires_grad attribute of tensor. Important for Attack\n", - " data.requires_grad = True\n", - "\n", - " # Forward pass the data through the model\n", - " output = model(data)\n", - " init_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n", - "\n", - " # If the initial prediction is wrong, don't bother attacking, just move on\n", - " if init_pred.item() != target.item():\n", - " continue\n", - "\n", - " # Calculate the loss\n", - " loss = F.nll_loss(output, target)\n", - "\n", - " # Zero all existing gradients\n", - " model.zero_grad()\n", - "\n", - " # Calculate gradients of model in backward pass\n", - " loss.backward()\n", - "\n", - " # Collect datagrad\n", - " data_grad = data.grad.data\n", - "\n", - " # Call FGSM Attack\n", - " perturbed_data = fgsm_attack(data, epsilon, data_grad)\n", - "\n", - " # Re-classify the perturbed image\n", - " output = model(perturbed_data)\n", - "\n", - " # Check for success\n", - " final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n", - " if final_pred.item() == target.item():\n", - " correct += 1\n", - " else:\n", - " # Save some adv examples for visualization later\n", - " if len(adv_examples) < 5:\n", - " adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n", - " adv_examples.append((init_pred.item(), final_pred.item(), adv_ex))\n", - "\n", - " # Calculate final accuracy for this epsilon\n", - " final_acc = correct / float(len(test_loader))\n", - " print(\n", - " \"Epsilon: {}\\tTest Accuracy = {} / {} = {}\".format(\n", - " epsilon, correct, len(test_loader), final_acc\n", - " )\n", - " )\n", - "\n", - " # Return the accuracy and an adversarial example\n", - " return final_acc, adv_examples" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the Attack" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "ε = 0.05" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f768f7a942484fedb9038755978fa436", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Running Attack on Batches with ε=0.05: 0%| | 0/10000 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, len(adv_examples), figsize=(8, 10))\n", - "plt.xticks([], [])\n", - "plt.yticks([], [])\n", - "for j, (orig_pred, adv_pred, adv_example) in enumerate(adv_examples):\n", - " if j == 0:\n", - " axes[j].set_ylabel(f\"ε: {ε}\", fontsize=14)\n", - " axes[j].set_title(\"{} -> {}\".format(orig_pred, adv_pred))\n", - " axes[j].imshow(adv_example, cmap=\"gray\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise:\n", - "\n", - "Now the question is: how much degradation in performance we have as soon as we keep incrementing the value of ε?\n", - "\n", - "What we should expect: \n", - "- the bigger ε, the worse the accuracy\n", - "- the bigger ε, the more \"discoverable\" the perturbation becomes\n", - " - so that it's evident that an attack has been launched" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6295f542b2a64e4d8d9a52298a18c6c5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Running Attack on Batches with ε=0.06: 0%| | 0/10000 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(5, 5))\n", - "\n", - "# your code here: plot Accuracies vs EPSILONS\n", - "plt.plot(EPSILONS, accuracies)\n", - "plt.yticks(np.arange(0, 1.1, step=0.1))\n", - "plt.xticks(np.arange(0, 0.35, step=0.05))\n", - "plt.title(\"Accuracy vs Epsilon\")\n", - "plt.xlabel(\"Epsilon\")\n", - "plt.ylabel(\"Accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "2. Visualise Generated Adversarial Examples" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot several examples of adversarial samples at each epsilon\n", - "\n", - "for ε in EPSILONS:\n", - " fig, axes = plt.subplots(1, len(adv_examples_map[ε]), figsize=(8, 10))\n", - " plt.xticks([], [])\n", - " plt.yticks([], [])\n", - " for j, (orig_pred, adv_pred, adv_example) in enumerate(adv_examples_map[ε]):\n", - " if j == 0:\n", - " axes[j].set_ylabel(f\"ε: {ε}\", fontsize=14)\n", - " axes[j].set_title(\"{} -> {}\".format(orig_pred, adv_pred))\n", - " axes[j].imshow(adv_example, cmap=\"gray\")\n", - " plt.tight_layout()\n", - " plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/2-ml-models-attacks/1-FSGM-Attack.ipynb b/2-ml-models-attacks/1-FSGM-Attack.ipynb new file mode 100644 index 0000000..ad7e9f2 --- /dev/null +++ b/2-ml-models-attacks/1-FSGM-Attack.ipynb @@ -0,0 +1,579 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext notexbook\n", + "%texify" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fast Gradient Sign Attack" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook showcases how to carry out a **Fast Gradient Sign Attack** (`FGSA`) to a pretrained model. \n", + "\n", + "**Note** This notebook has been adapted from the [FSGM Tutorial](https://pytorch.org/tutorials/beginner/fgsm_tutorial.html) by _Nathan Inkawhich_ `@inkawhich` available on the official [PyTorch Documentation](https://pytorch.org/docs/stable/index.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(_from the original notebook_)\n", + "> This tutorial will raise your awareness to the security vulnerabilities \n", + "> of ML models, and will give insight into the hot topic of adversarial machine learning. \n", + "> \n", + "> You may be surprised to find that adding **imperceptible perturbations** to an image *can* cause \n", + "> drastically different model performance.\n", + "> `[...]`\n", + ">\n", + "> Specifically we will use one of the first and most popular attack methods, the _Fast Gradient Sign Attack_\n", + "> (`FGSM`), to fool an `MNIST` classifier.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Threats to Models\n", + "\n", + "There are several kinds of assumptions of the attacker’s knowledge, two of which are: **white-box** and **black-box**. \n", + "\n", + "- A *white-box* attack assumes the attacker has full knowledge and access to the model, including\n", + "architecture, inputs, outputs, and weights. \n", + "- A *black-box* attack assumes the attacker only has access to the inputs and outputs of the model, and knows nothing about the underlying architecture or weights. \n", + "\n", + "There are also several types of goals, including **misclassification** and\n", + "**source/target misclassification**. \n", + "\n", + "A goal of *misclassification* means the adversary only wants the output classification to be wrong but does\n", + "not care what the new classification is. \n", + "\n", + "A *source/target misclassification* means the adversary wants to alter an image that is originally of a specific source class so that it is classified as a specific target class." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fast Gradient Sign Attack\n", + "\n", + "*Fast Gradient Sign Attack (FGSM)* and is described by _Goodfellow et. al._ in \n", + "[Explaining and Harnessing Adversarial Examples](https://arxiv.org/abs/1412.6572). \n", + "\n", + "The attack is remarkably powerful, and yet intuitive. \n", + "\n", + "It is designed to attack neural networks by leveraging the way they learn: **gradients**. \n", + "\n", + "The idea is simple: \n", + "\n", + "> rather than working to minimize the loss by adjusting the weights based on the backpropagated gradients,\n", + "> the attack **adjusts** the input data to maximize the loss based on the same backpropagated gradients. \n", + "\n", + "In other words, the attack uses the gradient of the loss w.r.t the input data, then adjusts the input data to maximize the loss.\n", + "\n", + "_(from the original paper)_\n", + "\n", + "![fgsm panda attack](https://pytorch.org/tutorials/_images/fgsm_panda_image.png)\n", + "\n", + "**TLDR;** Just perturbe the input data with some small change that would work in an **adversary** fashion (wrt. the optimisation process) that follows the **direction of the gradient** (i.e. $sign(\\nabla_{x} J(\\mathbf{\\theta}, \\mathbf{x}, y))$ )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "\n", + "from torch.utils.data import DataLoader\n", + "from torchvision import datasets, transforms\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", + "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", + "from six.moves import urllib\n", + "\n", + "opener = urllib.request.build_opener()\n", + "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", + "urllib.request.install_opener(opener)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import os \n", + "\n", + "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(DATA_FOLDER)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Reproducibility Settings\n", + "\n", + "import numpy as np\n", + "\n", + "SEED = 123456\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "\n", + "if torch.cuda.is_available():\n", + " torch.cuda.manual_seed_all(SEED)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### `LeNet` Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# LeNet Model definition\n", + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n", + " self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n", + " self.conv2_drop = nn.Dropout2d()\n", + " self.fc1 = nn.Linear(320, 50)\n", + " self.fc2 = nn.Linear(50, 10)\n", + "\n", + " def forward(self, x):\n", + " x = F.relu(F.max_pool2d(self.conv1(x), 2))\n", + " x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n", + " x = x.view(-1, 320)\n", + " x = F.relu(self.fc1(x))\n", + " x = F.dropout(x, training=self.training)\n", + " x = self.fc2(x)\n", + " return F.log_softmax(x, dim=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialise pre-trained model (and move it to available device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if torch.cuda.is_available():\n", + " dev_name = \"cuda\"\n", + "elif torch.backends.mps.is_available():\n", + " dev_name = \"mps\"\n", + "else:\n", + " dev_name = \"cpu\"\n", + "\n", + "device = torch.device(dev_name)\n", + "print(f\"You will be using the {device} device\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "torch.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment this when running on Anaconda Notebooks\n", + "# !wget !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/lenet_mnist_model.pth" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PRETRAINED_MODEL_WEIGHTS = \"lenet_mnist_model.pth\"\n", + "\n", + "# Initialize the network\n", + "model = Net().to(device)\n", + "\n", + "# Load the pretrained model\n", + "model.load_state_dict(torch.load(PRETRAINED_MODEL_WEIGHTS, map_location=device))\n", + "\n", + "# Set the model in evaluation mode. In this case this is for the Dropout layers\n", + "model.eval()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Download MNIST Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# MNIST Test dataset and dataloader declaration\n", + "mnist_test = datasets.MNIST(root=DATA_FOLDER, train=False, download=True, transform=transforms.ToTensor())\n", + "test_loader = torch.utils.data.DataLoader(mnist_test, batch_size=1, shuffle=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Before the Attack\n", + "\n", + "Before carrying out the attack, let's see how well the model classify the digits in the test set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "from tqdm.notebook import tqdm\n", + "\n", + "y_preds, y_true = list(), list()\n", + "with torch.no_grad(): # extra, as model is eval mode anyway\n", + " for (image, target) in tqdm(test_loader):\n", + " image, target = image.to(device), target.to(device)\n", + " out = model(image)\n", + " _, preds = torch.max(out, 1)\n", + " y_preds.append(preds.detach().cpu().numpy())\n", + " y_true.append(target.detach().cpu().numpy())\n", + " y_preds = np.hstack(y_preds)\n", + " y_true = np.hstack(y_true)\n", + " \n", + " print(f\"Pre-Trained Model ACC: {accuracy_score(y_true, y_preds)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `FSGM` Attack" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can define the function that creates the adversarial examples by\n", + "perturbing the original inputs. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# FGSM attack code\n", + "def fgsm_attack(image: torch.Tensor, epsilon: float, data_gradient: torch.Tensor) -> torch.Tensor:\n", + " # Collect the element-wise sign of the data gradient\n", + " sign_data_grad = data_gradient.sign()\n", + " # Create the perturbed image by adjusting each pixel of the input image\n", + " perturbed_image = image + (epsilon * sign_data_grad)\n", + " # Adding clipping to maintain [0,1] range\n", + " perturbed_image = torch.clamp(perturbed_image, 0, 1) # normalise in [0, 1] to make it an actual image\n", + " # Return the perturbed image\n", + " return perturbed_image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last but not least: the **test function**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test(model, device, loader, epsilon):\n", + " # from https://github.com/pytorch/tutorials/blob/master/beginner_source/fgsm_tutorial.py\n", + " \n", + " # Accuracy counter\n", + " correct = 0\n", + " adv_examples = []\n", + "\n", + " # Loop over all examples in test set\n", + " for data, target in tqdm(test_loader, desc=f\"Running Attack on Batches with ε={ε}\"):\n", + "\n", + " # Send the data and label to the device\n", + " data, target = data.to(device), target.to(device)\n", + "\n", + " # Set requires_grad attribute of tensor. Important for Attack\n", + " data.requires_grad = True\n", + "\n", + " # Forward pass the data through the model\n", + " output = model(data)\n", + " init_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n", + "\n", + " # If the initial prediction is wrong, don't bother attacking, just move on\n", + " if init_pred.item() != target.item():\n", + " continue\n", + "\n", + " # Calculate the loss\n", + " loss = F.nll_loss(output, target)\n", + "\n", + " # Zero all existing gradients\n", + " model.zero_grad()\n", + "\n", + " # Calculate gradients of model in backward pass\n", + " loss.backward()\n", + "\n", + " # Collect datagrad\n", + " data_grad = data.grad.data\n", + "\n", + " # Call FGSM Attack\n", + " perturbed_data = fgsm_attack(data, epsilon, data_grad)\n", + "\n", + " # Re-classify the perturbed image\n", + " output = model(perturbed_data)\n", + "\n", + " # Check for success\n", + " final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n", + " if final_pred.item() == target.item():\n", + " correct += 1\n", + " else:\n", + " # Save some adv examples for visualization later\n", + " if len(adv_examples) < 5:\n", + " adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n", + " adv_examples.append((init_pred.item(), final_pred.item(), adv_ex))\n", + "\n", + " # Calculate final accuracy for this epsilon\n", + " final_acc = correct / float(len(test_loader))\n", + " print(\n", + " \"Epsilon: {}\\tTest Accuracy = {} / {} = {}\".format(\n", + " epsilon, correct, len(test_loader), final_acc\n", + " )\n", + " )\n", + "\n", + " # Return the accuracy and an adversarial example\n", + " return final_acc, adv_examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the Attack" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ε = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "acc, adv_examples = test(model, device, test_loader, ε)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's see how the perturbed images look like: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, len(adv_examples), figsize=(8, 10))\n", + "plt.xticks([], [])\n", + "plt.yticks([], [])\n", + "for j, (orig_pred, adv_pred, adv_example) in enumerate(adv_examples):\n", + " if j == 0:\n", + " axes[j].set_ylabel(f\"ε: {ε}\", fontsize=14)\n", + " axes[j].set_title(\"{} -> {}\".format(orig_pred, adv_pred))\n", + " axes[j].imshow(adv_example, cmap=\"gray\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise:\n", + "\n", + "Now the question is: how much degradation in performance we have as soon as we keep incrementing the value of ε?\n", + "\n", + "What we should expect: \n", + "- the bigger ε, the worse the accuracy\n", + "- the bigger ε, the more \"discoverable\" the perturbation becomes\n", + " - so that it's evident that an attack has been launched" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "EPSILONS = [0.05, .06, .1, .15, .2, .25, .3]\n", + "\n", + "accuracies = [acc]\n", + "adv_examples_map = {0.05: adv_examples}\n", + "\n", + "# Run test for each epsilon\n", + "for ε in EPSILONS[1:]:\n", + " acc, adv_examples = test(model, device, test_loader, ε)\n", + " accuracies.append(acc)\n", + " adv_examples_map[ε] = adv_examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Results\n", + "\n", + "1. Let's print the accuracy values for each corresponding ε value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "accuracies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "\n", + "# your code here: plot Accuracies vs EPSILONS\n", + "plt.plot(EPSILONS, accuracies)\n", + "plt.yticks(np.arange(0, 1.1, step=0.1))\n", + "plt.xticks(np.arange(0, 0.35, step=0.05))\n", + "plt.title(\"Accuracy vs Epsilon\")\n", + "plt.xlabel(\"Epsilon\")\n", + "plt.ylabel(\"Accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Visualise Generated Adversarial Examples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot several examples of adversarial samples at each epsilon\n", + "\n", + "for ε in EPSILONS:\n", + " fig, axes = plt.subplots(1, len(adv_examples_map[ε]), figsize=(8, 10))\n", + " plt.xticks([], [])\n", + " plt.yticks([], [])\n", + " for j, (orig_pred, adv_pred, adv_example) in enumerate(adv_examples_map[ε]):\n", + " if j == 0:\n", + " axes[j].set_ylabel(f\"ε: {ε}\", fontsize=14)\n", + " axes[j].set_title(\"{} -> {}\".format(orig_pred, adv_pred))\n", + " axes[j].imshow(adv_example, cmap=\"gray\")\n", + " plt.tight_layout()\n", + " plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/2-ml-models-attacks/1-MIA-Training.ipynb b/2-ml-models-attacks/1-MIA-Training.ipynb deleted file mode 100644 index ea6720e..0000000 --- a/2-ml-models-attacks/1-MIA-Training.ipynb +++ /dev/null @@ -1,3644 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "d4e39d12-6b19-451d-b1b9-2502d6f8e15a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "
\n", - " The notebook is using\n", - " \n", - " no$\\TeX$book Jupyter Theme (release 2.0.1).\n", - "\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Optional: setup NoTexBook theme\n", - "%load_ext notexbook\n", - "\n", - "%texify" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "61fc7ebf", - "metadata": {}, - "outputs": [], - "source": [ - "# UNCOMMENT THIS ONLY if running on Anaconda Notebooks\n", - "\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/dataset.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/models.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/train.py" - ] - }, - { - "cell_type": "markdown", - "id": "dcd69b34", - "metadata": {}, - "source": [ - "# Model Inversion Attack - Model Training" - ] - }, - { - "cell_type": "markdown", - "id": "85ed1933", - "metadata": {}, - "source": [ - "In this notebook we will be performing the training of **two** (out of three) of the ML models considered in the paper:\n", - "\n", - "> **Model Inversion Attacks that Exploit Confidence Information and Basic Countermeasures**, by _Fredrikson, et. al_, 2015 \n", - "[DOI](https://dl.acm.org/doi/pdf/10.1145/2810103.2813677).\n", - "\n", - "The two models are `SoftmaxRegression` and `MLP`.\n", - "\n", - "⚠️ **NOTE**: Please feel free to skip this notebook completely (if you don't want to **re-train** the models on your own) and jump directly to the next [MIA Reconstruction](./2-MIA-Reconstruction.ipynb) notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "eee64647", - "metadata": {}, - "outputs": [], - "source": [ - "import torch as th\n", - "import numpy as np\n", - "\n", - "from matplotlib import pyplot as plt\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3126b393", - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", - "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", - "from six.moves import urllib\n", - "\n", - "opener = urllib.request.build_opener()\n", - "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", - "urllib.request.install_opener(opener)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9086c266", - "metadata": {}, - "outputs": [], - "source": [ - "from dataset import ORLFaces\n", - "from torchvision.transforms import ToTensor, Grayscale, Compose\n", - "from torch.utils.data import DataLoader" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bbc48ffb", - "metadata": {}, - "outputs": [], - "source": [ - "# Reproducibility Settings\n", - "\n", - "SEED = 123456\n", - "\n", - "np.random.seed(SEED)\n", - "th.manual_seed(SEED)\n", - "if th.cuda.is_available():\n", - " th.cuda.manual_seed_all(SEED)\n", - " th.backends.cudnn.deterministic = True" - ] - }, - { - "cell_type": "markdown", - "id": "5dc0251e", - "metadata": {}, - "source": [ - "### The `ORLFaces` Dataset\n", - "\n", - "The original paper considers the **AT&T Face Database** faces dataset (which I have encapsualted and made available as a PyTorch `Dataset`): `ORLFaces`" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "345e23a7", - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import os\n", - "\n", - "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "2ee5718e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/leriomaggio/Code/Python/Anaconda/ml_ai_program/tutorials/scipy_2023/ppml-tutorial/3-ml-models-attacks/../data\n" - ] - } - ], - "source": [ - "print(DATA_FOLDER)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c16625ec", - "metadata": {}, - "outputs": [], - "source": [ - "imgs_trasform = Compose([Grayscale(num_output_channels=1), ToTensor()])\n", - "\n", - "orl_faces_train = ORLFaces(\n", - " root=DATA_FOLDER, download=True, split=\"train\", transform=imgs_trasform\n", - ")\n", - "orl_faces_test = ORLFaces(\n", - " root=DATA_FOLDER, download=True, split=\"test\", transform=imgs_trasform\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "b9ae6a51", - "metadata": {}, - "outputs": [], - "source": [ - "BATCH_SIZE = 32\n", - "\n", - "train_loader = DataLoader(\n", - " orl_faces_train, batch_size=BATCH_SIZE, shuffle=True, drop_last=False\n", - ")\n", - "test_loader = DataLoader(\n", - " orl_faces_test, batch_size=BATCH_SIZE, shuffle=False, drop_last=False\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "bd2b2a27", - "metadata": {}, - "source": [ - "#### A few notes about the dataset \n", - "\n", - "The `ORLFaces` dataset contains `400` image files corresponding to `40` different subjects (`10` photo each).\n", - "\n", - "\n", - "Images are `112x92` pixels, with `256` grey levels per pixel, and (originally) stored in `PGM` format.\n", - "The photos of the subjects have been taken at different times, are varying the lightning, the facial expressions\n", - " (e.g. open/closed eyes, smiling/serious face), and the facial details.\n", - "\n", - "**Train/Test** partitions have been generated similarly to what has been done in the original paper, that is: \n", - "\n", - "(for each subject):\n", - "\n", - "- Randomly pick $7$ (out of $10$) images of the subject and add them to the **training set**\n", - "- Add remaining $3$ images to the **test set**" - ] - }, - { - "cell_type": "markdown", - "id": "425c305c", - "metadata": {}, - "source": [ - "#### Visualise a few Samples in the Dataset\n", - "\n", - "Before we start with the training, let's visualise a few random samples extracted from the dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "61e794b9", - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.utils import make_grid\n", - "\n", - "\n", - "def imshow(img):\n", - " npimg = img.numpy()\n", - " plt.figure(figsize=(10, 12))\n", - " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "aa210aaf", - "metadata": {}, - "outputs": [], - "source": [ - "# get some random training images\n", - "images, labels = next(iter(train_loader))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "089395c5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([32, 1, 112, 92])" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7dc07e43", - "metadata": {}, - "outputs": [], - "source": [ - "# show images\n", - "imshow(make_grid(images))\n", - "# print labels\n", - "print(\" \".join(f\"{labels[j]}\" for j in range(BATCH_SIZE)))" - ] - }, - { - "cell_type": "markdown", - "id": "2513010f", - "metadata": {}, - "source": [ - "ℹ️ **Note**: Do you see the **exact same faces** that are being displayed here? " - ] - }, - { - "cell_type": "markdown", - "id": "2b7b9841", - "metadata": {}, - "source": [ - "## Machine Learning Model Training\n", - "\n", - "In the original Paper, authors refer to three separated models used as reference examples for the Model Inversion Attack. \n", - "\n", - "Here to keep things simple, we will only consider two of them: `SoftmaxRegression` and `MLP`" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e0d1c795", - "metadata": {}, - "outputs": [], - "source": [ - "from models import SoftmaxRegression, MLP" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "b14bbfe8", - "metadata": {}, - "outputs": [], - "source": [ - "from train import train" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "9a193ca3", - "metadata": {}, - "outputs": [], - "source": [ - "λ = 0.1 # optimiser learning rate, as used in the paper" - ] - }, - { - "cell_type": "markdown", - "id": "7b9d5e71", - "metadata": {}, - "source": [ - "#### Training `SoftmaxRegression`\n", - "\n", - "Note: This should be super-fast even on a laptop (small model, small data)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "62df081d", - "metadata": {}, - "outputs": [], - "source": [ - "softmax_reg = SoftmaxRegression()\n", - "softmax_sgd = th.optim.SGD(softmax_reg.parameters(), lr=λ)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "cb471d2d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "SoftmaxRegression(\n", - " (regression): Linear(in_features=10304, out_features=40, bias=True)\n", - ")" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "softmax_reg" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "c4e0f0a2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using mps Device\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fae23ca4d7684c9caa7417a1b6299848", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Epochs: 0%| | 0/100 [00:00\n", - " /*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "*/\n", - "\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ======================================================\n", - " FONTS\n", - "\n", - " FONT WEIGHT MAP:\n", - " ----------------\n", - " 100: Ultra Light\n", - " 200: Thin\n", - " 300: Light\n", - " 400: Regular (normal)\n", - " 500: Medium\n", - " 600: Semi-bold\n", - " 700: Bold\n", - " 800: Heavy\n", - " 900: Black\n", - "\n", - " Font faces:\n", - " - ====================================|=======================\n", - " - Scope | Font Family Name\n", - " - ====================================| ======================\n", - " - Markdown Display (Computer Modern) (CMU Serif)\n", - " - Markdown Display monospace (CMU Typewriter Text)\n", - " - Markdown Edit monospace (Hack)\n", - " - Source Code monospace (Fira Code)\n", - " - ====================================| =======================\n", - "\n", - " ====================================================== */\n", - "\n", - "/* Roboto Slab */\n", - "@import url(\"https://fonts.googleapis.com/css2?family=Roboto+Slab:wght@100;200;300;400;500;600;700;800;900&display=swap\");\n", - "/*md-display-computer-modern --> CMU Serif*/\n", - "@import url(\"https://fonts.cdnfonts.com/css/cmu-serif?styles=30038,30039,30037,30036\");\n", - "/*md-display-monospace --> CMU Typewriter Text*/\n", - "@import url(\"https://fonts.cdnfonts.com/css/cmu-typewriter-text?styles=24833,24829,24830,24831,24832,24834\");\n", - "/*code-monospace --> Fira Code*/\n", - "@import url(\"https://fonts.googleapis.com/css2?family=Fira+Code:wght@300;400;500&display=swap\");\n", - "/*md-edit-monospace --> Hack*/\n", - "@import url(\"https://fonts.cdnfonts.com/css/hack?styles=20708,20707,20705,20706\");\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - "======================================================\n", - "\n", - "\n", - " ---------------------------------\n", - " Code Mirror - Code Cell Highlight\n", - " ---------------------------------\n", - "\n", - " Define the Style for Code **and** Markdown editors (Themes)\n", - " Theme files are all located in the \"themes\" folder, and the\n", - " different styles for the Code and Markdown editors are\n", - " distinguished by a common prefix in the file names:\n", - "\n", - " --> Code editors Themes: \"themes/code_*\"\n", - " --> Markdown Editor Themes: \"themes/md_*\"\n", - "\n", - " Styles can be imported as separate CSS modules.\n", - "\n", - " Current stylesheet (editor.css) defines the CSS rules\n", - " for notebook tags and classes. These rules are\n", - " all based to colors defined in external Theme files.\n", - "\n", - " This would ease the definition of other custom CSS Editor themes\n", - "*/\n", - "\n", - "/* Code Editor theme */\n", - "\n", - " /*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ======================================================\n", - "\n", - "The color palette is inspired by Light\n", - " Material Design theme\n", - "Repo: https://github.com/JonaDuran/Material-Light-Theme/\n", - "*/\n", - "\n", - ":root {\n", - " /* Color Palette */\n", - " --ml-white: #ffffff;\n", - " --ml-light-white: #FAFAFA;\n", - " --ml-black: #24292E;\n", - " --ml-dark-blue : #01579B11;\n", - " --ml-dark-blue-2: #01579B22;\n", - " --ml-blue: #1565C0;\n", - " --ml-green: #2E7D32;\n", - " --ml-yellow: #A8601A;\n", - " --ml-cyan: #00838f;\n", - " --ml-magenta: #9C00B0;\n", - " --ml-red: #C0392B;\n", - " --ml-grey: #9E9E9E;\n", - " --ml-light-blue: #78909c;\n", - "\n", - "\n", - " /* Editor Theme */\n", - " --code-background-color: var(--ml-light-white);\n", - " --gutter-background: var(--ml-light-white);\n", - " --selection-background-color: var(--ml-dark-blue-2);\n", - " --line-numbers: var(--ml-grey);\n", - " --cursor: var(--ml-black);\n", - " --bracket: var(--ml-black);\n", - " --matching-bracket: var(--ml-blue);\n", - " --code-text-color: var(--ml-black);\n", - " --keywords: var(--ml-magenta);\n", - " --types: var(--ml-magenta);\n", - " --variables: var(--code-text-color);\n", - " --variables2: var(--ml-green);\n", - " --def: var(--ml-blue);\n", - " --property: var(--ml-blue);\n", - " --meta: var(--ml-light-blue);\n", - " --builtin: var(--ml-blue);\n", - " --attribute: var(--ml-blue);\n", - " --strings: var(--ml-yellow);\n", - " --strings2: var(--ml-grey);\n", - " --comments: var(--ml-grey);\n", - " --operator: var(--ml-magenta);\n", - " --numbers: var(--ml-red);\n", - " /* Dataframe */\n", - " --dataframe: var(--code-text-color);\n", - " --df-bg: var(--ml-light-white);\n", - " --df-thead: var(--ml-blue);\n", - " --df-thead-border: var(--ml-black);\n", - " --df-tr-hover: var(--selection-background-color);\n", - " --df-border: var(--ml-white);\n", - " --df-border-right: var(--ml-grey);\n", - " --df-th-bg: var(--ml-white);\n", - " /*ANSI Colours*/\n", - " --ansi-red: var(--ml-red);\n", - " --ansi-green: var(--ml-green);\n", - " --ansi-green-intense: var(--ml-grey);\n", - " --ansi-cyan: var(--ml-cyan);\n", - " --ansi-blue: var(--ml-blue);\n", - "}\n", - "\n", - "\n", - "\n", - "/* Markdown Editor theme */\n", - "\n", - " /*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ======================================================\n", - "\n", - " Custom Theme for Markdown Editor\n", - " based on Material Clear Theme.\n", - "\n", - " */\n", - "\n", - ":root {\n", - " /* Color Palette */\n", - " --md-ml-red: #C0392B;\n", - " --md-ml-yellow: #A8601A;\n", - " --md-ml-black: #24292E;\n", - " --md-ml-grey: #9E9E9E;\n", - " --md-ml-blue: #1565C0;\n", - " --md-ml-dark-blue: #01579B;\n", - " --md-ml-light-blue: #78909c;\n", - "\n", - " /* Editor Theme */\n", - " --editor-text: var(--md-ml-black);\n", - " --header: var(--md-ml-dark-blue);\n", - " --quote: var(--md-ml-grey);\n", - " --link: var(--md-ml-blue);\n", - " --attribute: var(--md-ml-red);\n", - " --tag: var(--md-ml-yellow);\n", - " --string: var(--md-ml-yellow);\n", - " --delimiter: var(--md-ml-black);\n", - " --monospace: var(--md-ml-light-blue);\n", - "}\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "*/\n", - "\n", - "/*\n", - " =================\n", - " Code Editor Theme\n", - " =================\n", - "*/\n", - "div.output_error pre,\n", - "div.output_result pre,\n", - "div.output_stream pre {\n", - " color: var(--code-text-color) !important;\n", - "}\n", - "\n", - ".cm-s-ipython.CodeMirror,\n", - ".cm-s-jupyter.CodeMirror {\n", - " background: var(--code-background-color);\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - ".cm-s-ipython div.CodeMirror-selected,\n", - ".cm-s-jupyter div.CodeMirror-selected {\n", - " cursor: pointer;\n", - " background: var(--selection-background-color);\n", - "}\n", - "\n", - ".cm-s-ipython .CodeMirror-gutters,\n", - ".cm-s-jupyter .CodeMirror-gutters {\n", - " background: var(--gutter-background);\n", - " border-right: 0;\n", - "}\n", - "\n", - ".cm-s-ipython .CodeMirror-linenumber,\n", - ".cm-s-jupyter .CodeMirror-linenumber {\n", - " color: var(--line-numbers);\n", - "}\n", - "\n", - ".cm-s-ipython .CodeMirror-cursor,\n", - ".cm-s-jupyter .CodeMirror-cursor {\n", - " border-left: 1px solid var(--cursor) !important;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-bracket,\n", - ".cm-s-jupyter span.cm-bracket {\n", - " /*color: #828282;*/\n", - " color: var(--bracket);\n", - "}\n", - "\n", - "span.CodeMirror-matchingbracket {\n", - " text-decoration: underline !important;\n", - " text-decoration-color: var(--matching-bracket) !important;\n", - " color: var(--matching-bracket) !important;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-keyword,\n", - ".cm-s-jupyter span.cm-keyword {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-variable,\n", - ".cm-s-jupyter span.cm-variable {\n", - " color: var(--variables);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-variable-2,\n", - ".cm-s-jupyter span.cm-variable-2 {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-def,\n", - ".cm-s-jupyter span.cm-def {\n", - " color: var(--def);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-property,\n", - ".cm-s-jupyter span.cm-property {\n", - " color: var(--property);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-meta,\n", - ".cm-s-jupyter span.cm-meta {\n", - " color: var(--meta);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-attribute,\n", - ".cm-s-jupyter span.cm-attribute {\n", - " color: var(--attribute);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-builtin,\n", - ".cm-s-jupyter span.cm-builtin {\n", - " color: var(--builtin)\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-string,\n", - ".cm-s-jupyter span.cm-string {\n", - " color: var(--strings);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-string-2,\n", - ".cm-s-jupyter span.cm-string-2 {\n", - " color: var(--strings2);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-comment,\n", - ".cm-s-jupyter span.cm-comment {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-operator,\n", - ".cm-s-jupyter span.cm-operator {\n", - " color: var(--operator);\n", - " font-weight: 400;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-number,\n", - ".cm-s-jupyter span.cm-number {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-type,\n", - ".cm-s-jupyter span.cm-type {\n", - " color: var(--types);\n", - "}\n", - "\n", - "/*\n", - "==============================\n", - "Markdown MathJax Customisation\n", - "==============================\n", - "*/\n", - "\n", - "/*This customisation only applies to Math Display showing the font bigger than normal*/\n", - ".MathJax_Display {\n", - " font-size: 2rem;\n", - "}\n", - "\n", - ".MathJax_Display .mjx-char {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - "}\n", - "\n", - ".MathJax_Display, .MathJax span {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "a .MathJax span {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "a:hover .MathJax span {\n", - " text-decoration: underline;\n", - " color: var(--link-color);\n", - "}\n", - "\n", - ".MathJax span[style*=\"STIXMathJax_Normal\"],\n", - ".MathJax span[style*=\"STIXMathJax_Normal-italic\"],\n", - ".MathJax span[style*=\"STIXMathJax_Main\"],\n", - ".MathJax span[style*=\"STIXMathJax_Variants\"] {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - "}\n", - "\n", - "\n", - "/*\n", - " Pygments CSS (replacement) for HTML export\n", - " ===========================================\n", - "\n", - " Original Pygments CSS rewrite thanks to @rubik\n", - " https://github.com/jupyter/nbconvert/issues/447#issuecomment-270766965\n", - "*/\n", - "\n", - ".highlight .hll, div.highlight > pre {\n", - " background-color: var(--code-background-color);\n", - " color: var(--code-text-color);\n", - " font-family: var(--txbk-code-font-family);\n", - " font-size: var(--txbk-code-font-size);\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - "/* Comment */\n", - ".highlight .c {\n", - " color: var(--comments);\n", - "}\n", - "\n", - "/* Error */\n", - ".highlight .err {\n", - " color: #960050;\n", - " background-color: #1e0010;\n", - "}\n", - "\n", - "/* Keyword */\n", - ".highlight .k {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Literal */\n", - ".highlight .l {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/* Name */\n", - ".highlight .n {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* HACK:\n", - "fix Interpreter mismatch pygments vs codemirror\n", - "mpl.rcParams <- rcParams will be highlighted as property (as in codemirror)\n", - "*/\n", - ".highlight .o + .n {\n", - " color: var(--property);\n", - "}\n", - "\n", - "/* Operator */\n", - ".highlight .o {\n", - " color: var(--code-text-color);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Punctuation */\n", - ".highlight .p {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* Comment.Multiline */\n", - ".highlight .cm {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Comment.Preproc */\n", - ".highlight .cp {\n", - " color: var(--meta);\n", - " font-style: normal;\n", - "}\n", - "\n", - ".highlight .cpf {\n", - " color: var(--meta);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Comment.Single */\n", - ".highlight .c1 {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Comment.Special */\n", - ".highlight .cs {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* @ Generic.Deleted */\n", - ".highlight .gd {\n", - " color: var(--red);\n", - "}\n", - "\n", - "/* Generic.Emph */\n", - ".highlight .ge {\n", - " font-style: italic\n", - "}\n", - "\n", - "/* @ Generic.Inserted */\n", - ".highlight .gi {\n", - " color: #a6e22e\n", - "}\n", - "\n", - "/* Generic.Strong */\n", - ".highlight .gs {\n", - " font-weight: 500 !important;\n", - "}\n", - "\n", - "/* @ Generic.Subheading */\n", - ".highlight .gu {\n", - " color: #75715e\n", - "}\n", - "\n", - "/* */\n", - "\n", - "/* Keyword.Constant */\n", - ".highlight .kc {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Declaration */\n", - ".highlight .kd {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Namespace */\n", - ".highlight .kn {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Pseudo */\n", - ".highlight .kp {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Reserved */\n", - ".highlight .kr {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Type */\n", - ".highlight .kt {\n", - " color: var(--types);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Literal.Date */\n", - ".highlight .ld {\n", - " color: var(--numbers)\n", - "}\n", - "\n", - "/* Literal.Number */\n", - ".highlight .m {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/* Literal.String */\n", - ".highlight .s {\n", - " color: var(--string);\n", - "}\n", - "\n", - "/* Name.Attribute */\n", - ".highlight .na {\n", - " color: var(--property);\n", - "}\n", - "\n", - "/* Name.Builtin */\n", - ".highlight .nb {\n", - " color: var(--builtin);\n", - "}\n", - "\n", - "/* Name.Class */\n", - ".highlight .nc {\n", - " color: var(--def);\n", - " font-weight: normal !important;\n", - "}\n", - "\n", - "/* @ Name.Constant */\n", - ".highlight .no {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Decorator */\n", - ".highlight .nd {\n", - " color: var(--builtin);\n", - "}\n", - "\n", - "/* @ Name.Entity */\n", - ".highlight .ni {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Exception */\n", - ".highlight .ne {\n", - " color: var(--code-text-color);\n", - " font-weight: normal !important;\n", - "}\n", - "\n", - "/* Name.Function */\n", - ".highlight .nf, .highlight .fm {\n", - " color: var(--def);\n", - "}\n", - "\n", - "/* @ Name.Label */\n", - ".highlight .nl {\n", - " color: var(--comments);\n", - "}\n", - "\n", - "/* Name.Namespace */\n", - ".highlight .nn {\n", - " color: var(--code-text-color);\n", - " font-weight: normal !important;\n", - "}\n", - "\n", - "/* @ Name.Other */\n", - ".highlight .nx {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* @ Name.Property */\n", - ".highlight .py {\n", - " color: var(--property);\n", - "}\n", - "\n", - "/* @ Name.Tag */\n", - ".highlight .nt {\n", - " color: var(--tag);\n", - "}\n", - "\n", - "/* @ Name.Variable */\n", - ".highlight .nv {\n", - " color: var(--variables);\n", - "}\n", - "\n", - "/* Operator.Word */\n", - ".highlight .ow {\n", - " color: var(--operator);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* @ Text.Whitespace */\n", - ".highlight .w {\n", - " color: var(--code-background-color);\n", - "\n", - "}\n", - "\n", - "/* Literal.Number.Bin */\n", - "/* Literal.Number.Float */\n", - "/* Literal.Number.Hex */\n", - "/* Literal.Number.Integer */\n", - "/* Literal.Number.Oct */\n", - ".highlight .mb,\n", - ".highlight .mf,\n", - ".highlight .mh,\n", - ".highlight .mi,\n", - ".highlight .mo {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/* Literal.String.Backtick */\n", - ".highlight .sb {\n", - " color: var(--strings2);\n", - "}\n", - "\n", - ".highlight .sc, /* Literal.String.Char */\n", - ".highlight .sd, /* Literal.String.Doc */\n", - ".highlight .s2, /* Literal.String.Double */\n", - ".highlight .sh, /* Literal.String.Heredoc */\n", - ".highlight .si, /* Literal.String.Interpol */\n", - ".highlight .sx, /* Literal.String.Other */\n", - ".highlight .sr, /* Literal.String.Regex */\n", - ".highlight .s1, /* Literal.String.Single */\n", - ".highlight .ss /* Literal.String.Symbol */\n", - "{\n", - " color: var(--strings);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Literal.String.Escape */\n", - ".highlight .se {\n", - " color: var(--red);\n", - "}\n", - "\n", - "/* Name.Builtin.Pseudo */\n", - ".highlight .bp {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Variable.Class */\n", - ".highlight .vc {\n", - " color: var(--variables);\n", - "}\n", - "\n", - "/* Name.Variable.Global */\n", - ".highlight .vg {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Variable.Instance */\n", - ".highlight .vi {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* Literal.Number.Integer.Long */\n", - ".highlight .il {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/*\n", - " Dataframe Colors\n", - " ----------------\n", - " Adapt Dataframe table to comply with the theme\n", - "*/\n", - "\n", - "table.dataframe {\n", - " color: var(--dataframe) !important;\n", - "}\n", - "\n", - "table.dataframe tbody tr th {\n", - " background-color: var(--df-bg);\n", - "}\n", - "\n", - "table.dataframe tbody tr:hover {\n", - " background-color: var(--df-tr-hover);\n", - "}\n", - "\n", - "table.dataframe td, table.dataframe th {\n", - " border: 1px solid var(--df-border);\n", - "}\n", - "\n", - "table.dataframe > th:not(:empty) {\n", - " background-color: var(--df-th-bg);\n", - "}\n", - "\n", - "table.dataframe tr:nth-child(2) th:empty,\n", - "table.dataframe tr:nth-child(2) th:empty {\n", - " border-right: 1px dotted var(--df-border-right);\n", - "}\n", - "\n", - "table.dataframe thead tr th:not(:empty) {\n", - " color: var(--df-thead);\n", - " border-bottom: 1px solid var(--df-thead-border);\n", - "}\n", - "\n", - "/* =======================================\n", - " ANSI colors\n", - " (stdout / stderr color customisation)\n", - " =======================================\n", - "*/\n", - "\n", - "span.ansi-green-fg {\n", - " color: var(--ansi-green) !important;\n", - "}\n", - "\n", - "span.ansi-green-intense-fg{\n", - " color: var(--ansi-green-intense) !important;\n", - "}\n", - "\n", - "span.ansi-red-fg {\n", - " color: var(--ansi-red) !important;\n", - "}\n", - "\n", - "span.ansi-cyan-fg {\n", - " color: var(--ansi-cyan) !important;\n", - "}\n", - "\n", - "span.ansi-blue-fg {\n", - " color: var(--ansi-blue) !important;\n", - "}\n", - "\n", - "span.ansi-bold {\n", - " font-weight: 500 !important;\n", - "}\n", - "\n", - "/* ----------------------------------- */\n", - "\n", - "/*\n", - " ======================\n", - " Markdown Editor Theme\n", - " ======================\n", - "*/\n", - "\n", - "div.text_cell.unrendered pre {\n", - " color: var(--editor-text) !important;\n", - "}\n", - "\n", - "span.cm-header {\n", - " color: var(--header) !important;\n", - " font-weight: 500;\n", - "}\n", - "\n", - "span.cm-quote {\n", - " color: var(--quote) !important;\n", - "}\n", - "\n", - "span.cm-string.cm-url {\n", - " color: var(--link) !important;\n", - "}\n", - "\n", - "span.cm-string {\n", - " color: var(--strings) !important;\n", - "}\n", - "/* Sometimes useful in Mono code Highlighting*/\n", - "span.cm-string-2 {\n", - " color: var(--strings2) !important;\n", - "}\n", - "\n", - "span.cm-link {\n", - " color: var(--link) !important;\n", - "}\n", - "\n", - "span.cm-attribute {\n", - " color: var(--attribute) !important;\n", - "}\n", - "\n", - "span.cm-tag {\n", - " color: var(--tag) !important;\n", - "}\n", - "\n", - "span.cm-delimiter {\n", - " color: var(--delimiter) !important;\n", - "}\n", - "\n", - "span.cm-comment {\n", - " color: var(--comments) !important;\n", - "}\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ---------------------------------------\n", - " CODE CELL OUTPUT (DISPLAY MODE)\n", - "\n", - " Pandas DataFrame - as HTML Table\n", - " (includes also HTML tables)\n", - "\n", - "\n", - " Note: This stylesheet does NOT include\n", - " any color nor background color for tables,\n", - " as those are assumed to be part of the\n", - " Coding colourisation theme.\n", - "\n", - " ---------------------------------------\n", - "*/\n", - "table.dataframe {\n", - " border-collapse: collapse;\n", - " border: none;\n", - " margin-left: 20px !important;\n", - " font-size: var(--txbk-code-font-size) !important;\n", - "}\n", - "\n", - "table.dataframe thead {\n", - " padding-bottom: 10px;\n", - "}\n", - "\n", - "table.dataframe thead tr {\n", - " font-style: normal;\n", - " padding: 5px 10px;\n", - " border-bottom: 1px solid;\n", - " vertical-align: middle;\n", - " text-align: center;\n", - " empty-cells: hide;\n", - "}\n", - "\n", - "table.dataframe thead tr th,\n", - "table.dataframe thead tr:only-child th {\n", - " vertical-align: middle;\n", - " text-align: center;\n", - "}\n", - "\n", - "table.dataframe tbody {\n", - " padding-top: 5px;\n", - "}\n", - "\n", - "table.dataframe tbody tr {\n", - "}\n", - "\n", - "table.dataframe tbody tr th {\n", - " text-align: left !important;\n", - " font-style: italic;\n", - " font-weight: normal;\n", - " margin-right: 5px;\n", - "}\n", - "\n", - "table.dataframe tbody tr td {\n", - " padding-left: 1.0rem;\n", - " padding-right: 1.0rem;\n", - "}\n", - "\n", - "table.dataframe tr {\n", - " border: none;\n", - "}\n", - "\n", - "table.dataframe td,\n", - "table.dataframe th {\n", - " padding-left: 0.25em;\n", - " padding-right: 0.25em;\n", - "}\n", - "\n", - "table.dataframe > th:not(:empty) {\n", - " text-align: left;\n", - " padding: 0 10px;\n", - " font-style: italic\n", - "}\n", - "\n", - "table.dataframe tr:nth-child(2) th:empty,\n", - "table.dataframe tr:nth-child(2) th:empty {\n", - " border-left: none;\n", - "}\n", - "\n", - "table.dataframe td {\n", - " padding: 0.375em 1em;\n", - "}\n", - "\n", - "table.dataframe thead {\n", - "\tpadding: 10px 0;\n", - "\tfont-weight: bold;\n", - "}\n", - "\n", - "table.dataframe thead tr th:not(:empty) {\n", - " text-align: left;\n", - " font-style: normal;\n", - " padding: 5px 10px;\n", - "}\n", - "\n", - "/* Hacking Font-weight bold capped at 500 */\n", - ".rendered_html th {\n", - " font-weight: 500 !important;\n", - "}\n", - ":root {\n", - " /* Jupyter Lab Integration (Light Theme) */\n", - "\n", - " --jp-ui-font-family: var(--txbk-ui-font-family);\n", - " --jp-ui-font-color1: var(--txbk-ui-color);\n", - " --jp-ui-font-size1: var(--txbk-ui-font-size);\n", - "\n", - " --jp-content-font-color1: var(--txbk-content-mono-color);\n", - " --jp-content-font-family: var(--txbk-content-font-family);\n", - " --jp-content-line-height: var(--txbk-content-line-height);\n", - " --jp-content-link-color: var(--link-color);\n", - " --jp-content-font-size: var(--txbk-content-font-size);\n", - " --jp-content-heading-font-weight: bold;\n", - " --jp-content-heading-line-height: 1;\n", - "\n", - " --jp-layout-color3: #efefef;\n", - " --jp-notebook-multiselected-color: var(--txbk-multiselect-bgcolor);\n", - "\n", - " --jp-code-font-size: var(--txbk-code-font-size);\n", - " --jp-code-line-height: var(--txbk-ui-mono-line-height);\n", - " --jp-code-padding: 5px;\n", - " --jp-code-font-family-default: var(--txbk-code-font-family);\n", - " --jp-code-font-family: var(--jp-code-font-family-default);\n", - " --jp-code-presentation-font-size: var(--txbk-ui-mono-font-size);\n", - "\n", - " --jp-cell-prompt-font-family: var(--txbk-code-font-family);\n", - " --jp-cell-prompt-width: 80px;\n", - "\n", - " --jp-cell-editor-border-color: transparent;\n", - "\n", - " --jp-layout-color0: var(--code-background-color);\n", - " --jp-cell-prompt-not-active-font-color: #aba9a9;\n", - "\n", - " --jp-cell-editor-background: var(--code-background-color);\n", - " --jp-cell-editor-active-background: var(--code-background-color);\n", - " --jp-cell-editor-active-border-color: var(--txbk-cell-edit-border-color);\n", - "\n", - "}\n", - "\n", - "/* ================\n", - " Jupyter Lab UI\n", - " ================\n", - "*/\n", - "\n", - ".jp-DirListing-item.jp-mod-running .jp-DirListing-itemIcon:before {\n", - " color: var(--btn-danger);\n", - "}\n", - "\n", - ".jp-DirListing-item.jp-mod-selected {\n", - " background-color: var(--texbook-blue);\n", - " color: white;\n", - "}\n", - "\n", - "button.jp-RunningSessions-shutdownAll.jp-mod-styled {\n", - " color: var(--btn-warning)\n", - "}\n", - "\n", - "button.jp-RunningSessions-shutdownAll.jp-mod-styled {\n", - " color: var(--btn-warning);\n", - "}\n", - "\n", - ".jp-icon-warn0[fill] {\n", - " fill: var(--texbook-turquoise);\n", - "}\n", - "\n", - "#jp-MainLogo .jp-icon-warn0[fill] {\n", - " /* Set default not to override logo colour */\n", - " fill: var(--jp-warn-color0);\n", - "}\n", - "\n", - "/* Change Colour only of Icons on the left-hand side toolbar */\n", - ".jp-SideBar.lm-TabBar.jp-mod-left .jp-icon3[fill] {\n", - " fill: var(--texbook-yellow);\n", - "}\n", - "\n", - ".jp-SideBar.lm-TabBar.jp-mod-left.lm-TabBar-tab.lm-mod-current .jp-icon3[fill] {\n", - " fill: var(--texbook-orangex);\n", - "}\n", - "\n", - "/*Kernel*/\n", - "div.f14jk5uf[title=\"Kernel Busy\"] .jp-icon3[fill] {\n", - " fill: var(--kernel-busy);\n", - "}\n", - "\n", - "div.f14jk5uf[title=\"Kernel Idle\"] .jp-icon3[fill] {\n", - " fill: var(--kernel-idle);\n", - "}\n", - "\n", - "div.f14jk5uf[title=\"Kernel Unknown\"] .jp-icon3[fill],\n", - "div.f14jk5uf[title=\"Kernel Restarting\"] .jp-icon3[fill] {\n", - " fill: var(--kernel-disconnected);\n", - "}\n", - "\n", - "\n", - "/* body class*/\n", - "\n", - "body[data-jp-theme-light=\"true\"]:not(.jp-Notebook) {\n", - " font-family: var(--jp-ui-font-family);\n", - " background: var(--jp-layout-color3) !important;\n", - " margin: 0;\n", - " padding: 0;\n", - " overflow: hidden;\n", - "}\n", - "\n", - ".jp-Notebook {\n", - " background-color: var(--background-color) !important;\n", - " font-weight: 300;\n", - " color: var(--txbk-ui-color);\n", - " font-size: var(--txbk-ui-font-size);\n", - "}\n", - "\n", - "\n", - "/* -------------------------------------------------\n", - " HTML Cells output generics\n", - " (overriding default JupyterLab theme settings)\n", - " -------------------------------------------------\n", - "*/\n", - "\n", - ".jp-RenderedHTMLCommon :not(pre) > code {\n", - " background-color: transparent !important;\n", - " padding: 0 0 !important;\n", - "}\n", - "\n", - ".jp-RenderedHTMLCommon pre, .jp-RenderedHTMLCommon code {\n", - " background-color: transparent !important;\n", - "}\n", - "\n", - ".jp-RenderedHTMLCommon p {\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".jp-RenderedHTMLCommon * + p {\n", - " margin-top: 1em;\n", - "}\n", - "\n", - "\n", - "/* ======================================\n", - " MARKDOWN CELLS DISPLAY MODE\n", - " (text_cell_render in Notebook HTML)\n", - " ======================================\n", - "*/\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " color: var(--txbk-content-color) !important;\n", - " font-kerning: auto;\n", - " text-align: justify !important;\n", - " display: block;\n", - " word-break: normal !important;\n", - " word-wrap: break-word !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon a {\n", - " color: var(--link-color) !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h1,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h2,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h3,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h4,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h5,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h6 {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-style: normal !important;\n", - "}\n", - "\n", - "/* Font-sizes for Headers\n", - " ----------------------*/\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h1 {\n", - " font-size: 2.2em !important;\n", - " text-align: center !important;\n", - " padding-top: 3rem;\n", - " padding-bottom: 3rem;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h2 {\n", - " font-size: 1.9em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h3 {\n", - " font-size: 1.7em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h4 {\n", - " font-size: 1.5em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h5 {\n", - " font-size: 1.3em !important;\n", - " border-bottom: 1px solid rgb(204, 204, 204);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h6 {\n", - " font-size: 1.1em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon code {\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "\n", - "/* Monospace Code - no code syntax highlight*/\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre {\n", - " /* hack: using code background colour here to allow for compatibility */\n", - " background-color: var(--code-background-color) !important;\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p {\n", - " line-height: var(--txbk-content-line-height);\n", - " text-align: justify !important;\n", - "}\n", - "\n", - "/* Monospace inline rendered markdown */\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p code {\n", - " /*Re-defining variables for Mono using Code Editor's settings*/\n", - " font-size: var(--txbk-content-mono-font-size);\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p strong code {\n", - " font-weight: bold !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p em code {\n", - " font-style: italic !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre code {\n", - " padding: 1rem 1.5rem;\n", - " display: block;\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " word-wrap: break-word;\n", - " word-break: normal;\n", - " /* Important Override rules */\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon blockquote {\n", - " --txbk-ui-color: #6f6f6f;\n", - " margin: .2rem .2rem;\n", - " padding: .3rem .5rem;\n", - " border-left: .3rem solid #a7a7a7;\n", - " background-color: var(--txbk-content-mono-bgcolor);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon blockquote:not(:first-child) {\n", - " margin: 2rem .2rem;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon blockquote p {\n", - " padding: .2rem 1.5rem;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table {\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " border-collapse: collapse;\n", - " border-spacing: 0;\n", - " overflow: auto;\n", - " break-inside: auto;\n", - " margin-top: 25px;\n", - " margin-bottom: 15px;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table thead {\n", - " display: table-header-group;\n", - " vertical-align: middle;\n", - " border-bottom: none;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table thead tr,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table thead tr td,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tbody tr,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tbody tr th,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tbody tr td {\n", - " break-inside: avoid;\n", - " break-after: auto;\n", - " vertical-align: middle;\n", - " padding: 5px 5px;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tr th {\n", - " border-bottom-width: 0;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol {\n", - " position: relative;\n", - " display: block;\n", - " margin-bottom: 0 !important;\n", - " line-height: var(--txbk-content-line-height);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul {\n", - " list-style-type: disc;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul li,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol li {\n", - " padding: .25em;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul ul {\n", - " list-style-type: circle !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul li > ul li a code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul li > ol li a code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol li > ul li a code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol li > ol li a code {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul ul ul {\n", - " list-style-type: square !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img:only-child,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img:only-child {\n", - " display: block;\n", - " margin: auto;\n", - " max-width: 40%;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img {\n", - " max-width: 40%;\n", - "}\n", - "\n", - "/* Img MaxW classes */\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw10,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw10 {\n", - " max-width: 10% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw15,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw15 {\n", - " max-width: 15% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw20,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw20 {\n", - " max-width: 20% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw25,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw25 {\n", - " max-width: 25% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw30,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw30 {\n", - " max-width: 30% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw35,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw35 {\n", - " max-width: 35% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw40,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw40 {\n", - " max-width: 40% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw45,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw45 {\n", - " max-width: 45% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw50,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw50 {\n", - " max-width: 50% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw55,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw55 {\n", - " max-width: 55% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw60,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw60 {\n", - " max-width: 60% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw65,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw65 {\n", - " max-width: 65% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw70,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw70 {\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw75,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw75 {\n", - " max-width: 75% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw80,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw80 {\n", - " max-width: 80% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw85,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw85 {\n", - " max-width: 85% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw90,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw90 {\n", - " max-width: 90% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw95,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw95 {\n", - " max-width: 95% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw100,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw100 {\n", - " max-width: 100% !important;\n", - "}\n", - "\n", - "/* FIX Forcing monospace code to adhere with footnotes rules!*/\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p [id^='fn'] > code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p [class^='fn'] > code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "/* Code Cell Render (HTML output) */\n", - ".jp-CodeCell .jp-RenderedHTMLCommon {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-RenderedHTMLCommon p {\n", - " font-family: var(--txbk-code-font-family);\n", - " font-size: 1.4em;\n", - " font-weight: normal;\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-RenderedHTMLCommon .nomono {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-size: 1em;\n", - " margin-top: 0;\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell:not(.jp-mod-dropTarget) {\n", - " background: transparent;\n", - " border: none;\n", - "}\n", - "\n", - "/* Code Cell Editor */\n", - "\n", - ".jp-InputArea-editor {\n", - " background-color: var(--jp-cell-editor-active-background);\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell .jp-InputArea-editor,\n", - ".jp-Notebook .jp-MarkdownCell .jp-MarkdownOutput {\n", - " /* Set default LEFT border as transparent - to avoid change in paddings when selected */\n", - " border-left: 0.2rem dotted var(--txbk-cell-border-color);\n", - " box-shadow: none;\n", - " border-right: none;\n", - " border-top: none;\n", - " border-bottom: none;\n", - " overflow: hidden;\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell .jp-Cell-inputWrapper {\n", - " /* Set default RIGHT border as transparent - to avoid change in paddings when selected */\n", - " border-right: 5px solid var(--txbk-cell-border-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea-editor,\n", - ".jp-Notebook.jp-mod-commandMode .jp-MarkdownCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-MarkdownOutput {\n", - " /* Force border redefinition to override default Jupyter theme rules */\n", - " border-left: 0.2rem dotted var(--txbk-cell-selected-border-left-color);\n", - " box-shadow: none;\n", - " border-right: none;\n", - " border-top: none;\n", - " border-bottom: none;\n", - " overflow: hidden;\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-Cell-inputWrapper {\n", - " border-right-color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-editMode .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-Cell-inputWrapper {\n", - " border-right-color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - "/* Cell Multiple Selection */\n", - ".jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-selected:not(.jp-mod-active),\n", - ".jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-multiSelected {\n", - " border: 2px dashed var(--texbook-azure);\n", - " background: var(--txbk-multiselect-bgcolor);\n", - " margin-top: 10px;\n", - "}\n", - "\n", - "/*\n", - " Overlay with Shadow for Code Cell Selected !\n", - " ============================================\n", - "*/\n", - "/* Overlay limited to CodeCells */\n", - ".jp-Notebook .jp-CodeCell.jp-mod-selected {\n", - " border: none;\n", - " background: transparent;\n", - " box-shadow: 0 6px 18px #aaa;\n", - " z-index: 10;\n", - " top: -10px;\n", - " padding-top: 12px;\n", - " padding-bottom: 12px;\n", - " margin-top: 18px;\n", - " margin-bottom: 2px;\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell.jp-mod-active.jp-mod-selected:before {\n", - " position: absolute;\n", - " display: none;\n", - " top: -1px;\n", - " left: -1px;\n", - " width: 0;\n", - " height: calc(100% + 2px);\n", - " content: '';\n", - " background: none;\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell .jp-Collapser {\n", - " display: none !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-InputPrompt {\n", - " color: var(--texbook-light-grey) !important;\n", - " font-style: normal !important;\n", - " font-size: 1em;\n", - " opacity: 1 !important;\n", - " font-weight: normal;\n", - " min-width: 9.5ex;\n", - "}\n", - "\n", - ".jp-OutputPrompt {\n", - " color: transparent !important;\n", - " min-width: 9.5ex; /* Aligns with Input Prompt */\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-InputPrompt bdi,\n", - ".jp-Notebook .jp-CodeCell .jp-OutputPrompt bdi {\n", - " line-height: 0;\n", - " font-size:0;\n", - " color: transparent;\n", - " left: -10000px;\n", - " content: \"\\21E2\";\n", - "}\n", - "\n", - "/*.jp-Notebook .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputPrompt:before {*/\n", - ".jp-Notebook .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea:before {\n", - " display: inline-block;\n", - " position: absolute;\n", - " content: \"\\279E\";\n", - " font-size: 1.75rem;\n", - " top: 4px;\n", - " width: 10px;\n", - " left: 0;\n", - " font-weight: bold !important;\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-commandMode .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea:before {\n", - " color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-editMode .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea:before {\n", - " color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - "/* =============\n", - " Code Editors\n", - " ============= */\n", - "\n", - ".jp-Notebook .jp-Cell .CodeMirror * {\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .CodeMirror * {\n", - " font-family: var(--txbk-code-font-family) !important;\n", - " font-size: var(--txbk-code-font-size) !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .CodeMirror * {\n", - " font-family: var(--txbk-md-font-family) !important;\n", - " font-size: var(--txbk-md-font-size) !important;\n", - "}\n", - "\n", - "/* Cell Output rendering (.output_area in Notebook HTML) */\n", - "\n", - ".jp-OutputArea-output.jp-RenderedText pre,\n", - ".jp-OutputArea-output.jp-RenderedMarkdown p {\n", - " padding-bottom: 15px;\n", - " padding-top: 10px;\n", - "}\n", - "\n", - ".jp-OutputArea-output.jp-RenderedMarkdown p {\n", - " font-size: var(--txbk-content-font-size);\n", - "}\n", - "\n", - ".jp-OutputArea-output.jp-RenderedMarkdown pre code {\n", - " font-size: var(--txbk-content-mono-font-size);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - ".jp-OutputArea-output.jp-RenderedText pre {\n", - " --txbk-content-mono-font-family: var(--txbk-code-font-family);\n", - " font-size: var(--txbk-code-font-size);\n", - " font-weight: normal;\n", - " word-break: normal;\n", - " word-wrap: break-word;\n", - "}\n", - "\n", - "/* Standard Error */\n", - ".jp-RenderedText[data-mime-type='application/vnd.jupyter.stderr'] {\n", - " background: none !important;\n", - "}\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "*/\n", - "\n", - "/* HTML Export (Jupyter Light Theme)\n", - " ================================ */\n", - "\n", - "body.jp-Notebook .jp-CodeCell .jp-InputPrompt {\n", - " margin-top: 7px;\n", - " overflow: initial;\n", - "}\n", - "\n", - "body.jp-Notebook .CodeMirror-linenumber {\n", - " --txbk-ui-mono-font-size: 10px !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-RenderedHTMLCommon.jp-MarkdownOutput p > img:only-child,\n", - "body.jp-Notebook .jp-RenderedHTMLCommon.jp-MarkdownOutput img:only-child {\n", - " max-width: 30%;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-CodeCell .jp-InputPrompt {\n", - " font-size: var(--txbk-code-font-size);\n", - " padding-top: 4px;\n", - "}\n", - "\n", - "/* ==================================================\n", - " IMPORTANT NOTE:\n", - " ALL markdown rules cells needs adapting because of\n", - " a different structure in exported HTML\n", - " ===================================================\n", - "*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " color: var(--txbk-content-color) !important;\n", - " font-kerning: auto;\n", - " text-align: justify !important;\n", - " display: block;\n", - " word-break: normal !important;\n", - " word-wrap: break-word !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput a {\n", - " color: var(--link-color) !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h1,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h2,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h3,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h4,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h5,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h6 {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-style: normal !important;\n", - "}\n", - "\n", - "/* Font-sizes for Headers\n", - " ----------------------*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h1 {\n", - " font-size: 2.2em !important;\n", - " text-align: center !important;\n", - " padding-top: 3rem;\n", - " padding-bottom: 3rem;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h2 {\n", - " font-size: 1.9em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h3 {\n", - " font-size: 1.7em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h4 {\n", - " font-size: 1.5em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h5 {\n", - " font-size: 1.3em !important;\n", - " border-bottom: 1px solid rgb(204, 204, 204);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h6 {\n", - " font-size: 1.1em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput code {\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "\n", - "/* Monospace Code - no code syntax highlight*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre {\n", - " /* hack: using code background colour here to allow for compatibility */\n", - " background-color: var(--code-background-color) !important;\n", - " font-family: var(--txbk-content-mono-font-family) !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p {\n", - " line-height: var(--txbk-content-line-height);\n", - " text-align: justify !important;\n", - "}\n", - "\n", - "/* Monospace inline rendered markdown */\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p code {\n", - "\n", - " /*Re-defining variables for Mono using Code Editor's settings*/\n", - " --txbk-content-mono-font-family: var(--txbk-code-font-family);\n", - " --txbk-content-mono-font-size: var(--txbk-code-font-size);\n", - "\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p strong code {\n", - " font-weight: bold !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p em code {\n", - " font-style: italic !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-CodeCell .jp-RenderedHTMLCommon p.nomono {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-size: 1em;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre code {\n", - " padding: 1rem 1.5rem;\n", - " display: block;\n", - " color: var(--txbk-content-mono-color);\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " word-wrap: break-word;\n", - " word-break: normal;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput blockquote {\n", - " --txbk-ui-color: #6f6f6f !important;\n", - "\n", - " margin: 2rem .2rem !important;\n", - " padding: .3rem .5rem !important;\n", - " border-left: .3rem solid #a7a7a7 !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput blockquote p {\n", - " padding: .2rem 1.5rem;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table {\n", - " margin-top: 25px;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table {\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " border-collapse: collapse;\n", - " border-spacing: 0;\n", - " width: 100%;\n", - " overflow: auto;\n", - " break-inside: auto;\n", - " text-align: left;\n", - " margin-top: 25px;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table thead {\n", - " display: table-header-group;\n", - " vertical-align: middle !important;\n", - " border-bottom: none !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table thead tr,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table thead tr td,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tbody tr,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tbody tr th,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tbody tr td {\n", - " break-inside: avoid;\n", - " break-after: auto;\n", - " text-align: left !important;\n", - " vertical-align: middle !important;\n", - " padding: 0 !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tr th {\n", - " border-bottom-width: 0;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol {\n", - " position: relative;\n", - " display: block;\n", - " margin-bottom: 0 !important;\n", - " line-height: var(--txbk-content-line-height);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul {\n", - " list-style-type: disc;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li {\n", - " /*white-space: pre-wrap;*/\n", - " padding: .8rem !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > code {\n", - " font-size: .9em !important\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li a code {\n", - " font-size: .9em !important\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ul {\n", - " list-style-type: circle !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ul,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ol,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol ul,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol ol {\n", - " padding-top: .5rem !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ul li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ol li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ul li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ol li {\n", - " padding: .5rem !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ul li code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ol li code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ul li code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ol li code {\n", - " font-size: .9em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ul li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ol li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ul li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ol li a code {\n", - " font-size: .9em !important;\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ul ul {\n", - " list-style-type: square !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img:only-child,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img:only-child {\n", - " display: block;\n", - " margin: auto;\n", - " max-width: 40%;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img {\n", - " max-width: 40%;\n", - "}\n", - "\n", - "/* Img MaxW classes */\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw10,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw10 {\n", - " max-width: 5% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw15,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw15 {\n", - " max-width: 5% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw20,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw20 {\n", - " max-width: 10% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw25,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw25 {\n", - " max-width: 15% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw30,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw30 {\n", - " max-width: 20% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw35,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw35 {\n", - " max-width: 25% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw40,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw40 {\n", - " max-width: 30% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw45,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw45 {\n", - " max-width: 35% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw50,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw50 {\n", - " max-width: 40% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw55,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw55 {\n", - " max-width: 45% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw60,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw60 {\n", - " max-width: 50% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw65,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw65 {\n", - " max-width: 55% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw70,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw70 {\n", - " max-width: 60% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw75,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw75 {\n", - " max-width: 65% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw80,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw80 {\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw85,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw85 {\n", - " max-width: 75% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw90,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw90 {\n", - " max-width: 80% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw95,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw95 {\n", - " max-width: 85% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw100,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw100 {\n", - " max-width: 90% !important;\n", - "}\n", - "\n", - "/* FIX Forcing monospace code to adhere with footnotes rules!*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p [id^='fn'] > code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p [class^='fn'] > code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "\n", - "/* ======================================================\n", - " GLOBALS (with vars integration)\n", - " ======================================================\n", - "*/\n", - "\n", - "\n", - ":root {\n", - " --template-txbk-content-font-size: 16px;\n", - " --template-txbk-content-line-height: 1.4;\n", - " --template-txbk-content-mono-font-family: \"CMU Typewriter Text\", \"Fira Code\", monospace;\n", - " --template-txbk-code-font-family: \"Fira Code\", \"Fira Code\", monospace;\n", - " --template-txbk-md-font-family: \"Hack\", \"Hack\", monospace;\n", - " --template-txbk-code-font-size: 14px;\n", - " --template-txbk-md-font-size: 14px;\n", - "}\n", - "\n", - "/* ======================================================\n", - " GLOBALS\n", - " ======================================================\n", - "*/\n", - "\n", - ":root {\n", - " /* Base colors */\n", - " --texbook-red: #d43133;\n", - " --texbook-pink: #D14187;\n", - " --texbook-turquoise: #009489;\n", - " --texbook-azure: #00afde;\n", - " --texbook-blue: #2875d9;\n", - " --texbook-light-grey: #828282;\n", - " --texbook-dark-grey: rgb(56, 56, 56);\n", - " --texbook-yellow: #f9ab00;\n", - " --texbook-orange: #e8710a;\n", - "\n", - " /* Font formatting */\n", - " --background-color: #ffffff;\n", - " --txbk-ui-font-family: \"Roboto Slab\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n", - " --txbk-ui-color: rgb(51, 51, 51);\n", - " --txbk-ui-font-size: 14px;\n", - " --txbk-ui-line-height: 1;\n", - "\n", - " --txbk-ui-header-font-family: \"Roboto Slab\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n", - " --txbk-ui-header-color: rgb(56, 56, 56);\n", - "\n", - " --txbk-ui-mono-color: #828282;\n", - " --txbk-ui-mono-font-size: 15px;\n", - " --txbk-ui-mono-line-height: 1.4;\n", - "\n", - " /* Cells */\n", - " --txbk-cell-selected-border-left-color: lightgrey;\n", - " --txbk-cell-border-color: var(--background-color);\n", - " --txbk-multiselect-bgcolor: var(--background-color);\n", - " --txbk-cell-display-border-color: #009489;\n", - " --txbk-cell-edit-border-color: #d43133;\n", - "\n", - " /* Content Formatting */\n", - " --txbk-content-font-family: \"CMU Serif\", \"Times New Roman\", serif;\n", - " --txbk-content-font-size: var(--template-txbk-content-font-size);\n", - " --txbk-content-color: rgb(51, 51, 51);\n", - " --txbk-content-line-height: var(--template-txbk-content-line-height);\n", - "\n", - " --txbk-content-mono-font-family: var(--template-txbk-content-mono-font-family);\n", - " --txbk-content-mono-font-size: var(--txbk-content-font-size);\n", - " --txbk-content-mono-color: var(--texbook-dark-grey);\n", - " --txbk-content-mono-bgcolor: var(--code-background-color);\n", - "\n", - " --txbk-code-font-family: var(--template-txbk-code-font-family);\n", - " --txbk-code-font-size: var(--template-txbk-code-font-size);\n", - " --txbk-md-font-family: var(--template-txbk-md-font-family);\n", - " --txbk-md-font-size: var(--template-txbk-md-font-size);\n", - " --txbk-code-line-height: 1.6;\n", - " --txbk-code-color: var(--code-text-color);\n", - " --txbk-code-bgcolor: var(--code-background-color);\n", - "\n", - " --link-color: var(--texbook-blue);\n", - " --del-color: var(--texbook-red);\n", - " --drop-cap-color: var(--texbook-red);;\n", - "\n", - " --kernel-name-color: var(--texbook-azure);\n", - " --kernel-idle: var(--texbook-turquoise);\n", - " --kernel-busy: var(--texbook-pink);\n", - " --kernel-disconnected: var(--texbook-red);\n", - " --btn-warning: var(--texbook-pink);\n", - " --btn-danger: var(--texbook-red);\n", - " --running-notebook: var(--texbook-turquoise);\n", - "}\n", - "\n", - "html {\n", - " font-size: 10px;\n", - "}\n", - "\n", - "body {\n", - "\n", - " background-color: var(--background-color) !important;\n", - " font-weight: 300;\n", - " font-family: var(--txbk-ui-font-family);\n", - " color: var(--txbk-ui-color);\n", - " overflow: inherit;\n", - " vertical-align: middle;\n", - " font-size: var(--txbk-ui-font-size);\n", - "}\n", - "\n", - "h1, h2, h3, h4, h5, h6, label > strong {\n", - " font-family: var(--txbk-ui-header-font-family);\n", - " color: var(--txbk-ui-header-color);\n", - "}\n", - "\n", - "h1 img, h2 img , h3 img, h4 img, h5 img, h6 img {\n", - " display: inline !important;\n", - "}\n", - "\n", - "h1 {\n", - " font-weight: bold;\n", - " font-style: normal;\n", - "}\n", - "\n", - "h2 {\n", - " font-weight: bold;\n", - " font-style: italic;\n", - "}\n", - "\n", - "h3 {\n", - " font-weight: 600;\n", - " font-style: normal;\n", - "}\n", - "\n", - "h4 {\n", - " font-weight: 500;\n", - " font-style: normal;\n", - "}\n", - "\n", - "h5, h6 {\n", - " font-weight: 500;\n", - " font-style: italic;\n", - "}\n", - "\n", - "code, kbd, pre, samp {\n", - " font-family: var(--txbk-code-font-family);\n", - " color: var(--txbk-ui-mono-color);\n", - " font-weight: 400;\n", - " font-size: var(--txbk-ui-mono-font-size);\n", - " line-height: var(--txbk-ui-mono-line-height);\n", - "}\n", - "\n", - "table > thead > tr > td.info,\n", - "table > tbody > tr > td.info,\n", - "table > tfoot > tr > td.info,\n", - "table > thead > tr > th.info,\n", - "table > tbody > tr > th.info,\n", - "table > tfoot > tr > th.info,\n", - "table > thead > tr.info > td,\n", - "table > tbody > tr.info > td,\n", - "table > tfoot > tr.info > td,\n", - "table > thead > tr.info > th,\n", - "table > tbody > tr.info > th,\n", - "table > tfoot > tr.info > th {\n", - " background-color: #d9edf7;\n", - "}\n", - "\n", - "del {\n", - " color: var(--del-color) !important;\n", - "}\n", - "\n", - "/* ======================================================\n", - " Intro/Home Page Server\n", - " ======================================================\n", - "*/\n", - "\n", - "#ipython-main-app p {\n", - " text-align: justify !important;\n", - "}\n", - "\n", - ".toolbar_info,\n", - ".list-container {\n", - " color: #828282;\n", - "}\n", - "\n", - ".list_placeholder {\n", - " font-family: \"Roboto Slab\", serif !important;\n", - " font-weight: 300;\n", - " font-style: normal;\n", - "}\n", - "\n", - "a.item_link, a:hover.item_link {\n", - " color: var(--link-color);\n", - " font-weight: 300;\n", - "}\n", - "\n", - ".item_buttons .kernel-name {\n", - " color: var(--kernel-name-color);\n", - " font-weight: 400;\n", - "}\n", - "\n", - ".btn-warning {\n", - " background-color: var(--btn-warning) !important;\n", - " border-color: var(--btn-warning) !important;\n", - "}\n", - "\n", - ".btn-warning:focus {\n", - " border-color: var(--btn-warning) !important;\n", - "}\n", - "\n", - ".btn-danger {\n", - " background-color: var(--btn-danger) !important;\n", - " border-color: var(--btn-danger) !important;\n", - "}\n", - "\n", - ".btn-danger:focus {\n", - " border-color: var(--btn-danger) !important;\n", - "}\n", - "\n", - ".running-indicator,\n", - ".running_notebook_icon:before {\n", - " color: var(--running-notebook);\n", - "}\n", - "\n", - "\n", - "\n", - "/* ======================================================\n", - " Notebook\n", - " ======================================================\n", - "*/\n", - "\n", - "/* Modal Dialog */\n", - "\n", - ".modal-header > h4 {\n", - " font-style: normal !important;\n", - " text-decoration: none !important;\n", - " font-family: var(--txbk-ui-font-family) !important;\n", - " margin: 0 !important;\n", - "}\n", - "\n", - ".notebook_app {\n", - " background-color: var(--background-color) !important;\n", - " font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif !important;\n", - " font-weight: normal;\n", - "}\n", - "\n", - "div#notebook_name {\n", - " font-family: var(--txbk-ui-font-family) !important;\n", - " font-weight: normal;\n", - " font-size: 24px;\n", - " padding: 1px 7px 1px 1px;\n", - "}\n", - "\n", - "div#site {\n", - "\toverflow: inherit;\n", - " top: 112px;\n", - " position: absolute;\n", - "}\n", - "\n", - "#header {\n", - " display: block;\n", - " position: fixed !important;\n", - " top: 0;\n", - " width: 100%;\n", - " max-width: 100%;\n", - " height: fit-content;\n", - " background-color: var(--background-color);\n", - "}\n", - "\n", - "#notebook-container {\n", - " /* Remove shadow so that it looks like a page of a PDF doc */\n", - " box-shadow: none !important;\n", - " -webkit-box-shadow: none !important;\n", - " padding: 0;\n", - "}\n", - "\n", - "div#notebook {\n", - " border-top: none;\n", - " font-size: 1rem;\n", - " padding: 0 !important;\n", - " padding-top: 30px !important;\n", - " font-family: var(--txbk-content-font-family) !important;\n", - "}\n", - "\n", - ".kernel_idle_icon:before {\n", - " color: var(--kernel-idle);\n", - "}\n", - "\n", - ".kernel_busy_icon:before {\n", - " color: var(--kernel-busy);\n", - "}\n", - "\n", - ".kernel_disconnected_icon:before {\n", - " color: var(--kernel-disconnected);\n", - "}\n", - "\n", - "#notification_area {\n", - " font-family: var(--txbk-ui-font-family);\n", - "}\n", - "\n", - "#notification_kernel {\n", - " color: #fff;\n", - " background-color: var(--kernel-idle);\n", - " border-color: var(--kernel-idle);\n", - "}\n", - "\n", - "#notification_kernel.warning {\n", - " color: #fff;\n", - " background-color: var(--kernel-disconnected);\n", - " border-color: var(--kernel-disconnected);\n", - "}\n", - "\n", - "#notification_trusted {\n", - " border-color: var(--kernel-disconnected);\n", - "}\n", - "\n", - "#notification_trusted[disabled=\"disabled\"] {\n", - " border-color: var(--kernel-idle);\n", - "}\n", - "\n", - "\n", - "#notification_notebook {\n", - " border-color: var(--kernel-idle);\n", - "}\n", - "\n", - "/* -----------------------------------\n", - " CELLS\n", - " -----------------------------------\n", - "*/\n", - "\n", - "div.cell {\n", - " right: 2px;\n", - " border: none;\n", - " margin-top: 5px;\n", - "}\n", - "\n", - "div.cell.selected {\n", - " /* Reset all - ready for customisation */\n", - " border-radius: 0;\n", - " background: none;\n", - "}\n", - "\n", - "div.cell .inner_cell {\n", - " border-right: 5px solid var(--txbk-cell-border-color);\n", - " border-left: 0.2rem dotted var(--txbk-cell-border-color);\n", - "}\n", - "\n", - "div.cell.selected:not(.jupyter-soft-selected) .inner_cell {\n", - " border-left-color: var(--txbk-cell-selected-border-left-color);\n", - "}\n", - "\n", - ".command_mode div.cell.selected:not(.jupyter-soft-selected) .inner_cell {\n", - " border-right-color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".edit_mode div.cell.selected:not(.jupyter-soft-selected) .inner_cell {\n", - " border-right-color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - "/* Multiple Selection */\n", - ".command_mode div.cell.jupyter-soft-selected {\n", - " border: 2px dashed var(--texbook-azure);\n", - " background: var(--txbk-multiselect-bgcolor);\n", - " margin-top: 10px;\n", - "}\n", - "\n", - "/*\n", - "Overlay with Shadow for Code Cell Selected !\n", - "*/\n", - "div.code_cell.selected,\n", - ".command_mode div.code_cell.jupyter-soft-selected {\n", - " box-shadow: 0 6px 18px #aaa;\n", - " z-index: 10;\n", - " top: -10px;\n", - "}\n", - "\n", - "div.code_cell.selected {\n", - " border: none;\n", - " background: transparent;\n", - "}\n", - "\n", - "div.prompt {\n", - " font-family: var(--txbk-code-font-family) !important;\n", - " font-style: normal;\n", - " font-size: 1rem;\n", - " text-align: right;\n", - " line-height: 1rem;\n", - " min-width: 9ex;\n", - "}\n", - "\n", - "div.cell.selected:before,\n", - "div.cell.jupyter-soft-selected:before {\n", - " /* Important Needed to Override */\n", - " width: 0 !important;\n", - " background: none !important;\n", - "}\n", - "\n", - "div.cell div.input:before {\n", - " display: inline-block;\n", - " position: relative;\n", - " content: \"\\279E\";\n", - " font-size: 1.8rem;\n", - " top: 11px;\n", - " width: 10px;\n", - " left: 3px;\n", - " font-weight: bold;\n", - "}\n", - "\n", - "div.cell:not(.selected) div.input:before {\n", - " color: var(--background-color);\n", - "}\n", - "\n", - "div.cell.selected:not(.jupyter-soft-selected) div.input:before {\n", - " color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".edit_mode div.cell.selected div.input:before,\n", - ".edit_mode div.cell.selected.unrendered div.input:before {\n", - " color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - ".code_cell div.input_prompt:after,\n", - ".code_cell div.output_prompt:after {\n", - " display: inline-block;\n", - " content: '';\n", - " font-size: 0.75rem;\n", - " font-style: normal !important;\n", - "}\n", - "\n", - ".edit_mode div.cell.selected:before{\n", - " width: 0;\n", - " background: none;\n", - "}\n", - "\n", - "/* ==========================\n", - " Cell Input and Rendering\n", - " ==========================\n", - "*/\n", - "\n", - "div.input_area {\n", - " border-radius: 0;\n", - " border: none;\n", - " padding: 2px 5px 0 5px;\n", - "}\n", - "\n", - "div.input_prompt {\n", - " color: #aba9a9;\n", - " font-style: normal;\n", - " font-size: 1.4rem;\n", - " padding-top: 14px;\n", - "}\n", - "\n", - "/* FIX:\n", - " Fixing Empty cell output in HTML export\n", - "*/\n", - "div.output_prompt {\n", - " color: transparent !important;\n", - "}\n", - "\n", - "div.input_prompt bdi,\n", - "div.output_prompt bdi {\n", - " line-height: 0;\n", - " font-size:0;\n", - " color: transparent;\n", - " left: -10000px;\n", - " content: \"\\21E2\";\n", - "\n", - "}\n", - "\n", - "div.output_wrapper {\n", - " margin-top: 8px;\n", - "}\n", - "\n", - "div.output_area div.output_text pre,\n", - "div.output_area div.output_markdown p {\n", - " padding-bottom: 15px;\n", - " padding-top: 10px;\n", - "}\n", - "\n", - "div.output_area div.output_markdown p {\n", - " font-size: var(--txbk-content-font-size);\n", - "}\n", - "\n", - "div.output_area div.output_markdown pre code {\n", - " font-size: var(--txbk-content-mono-font-size);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "div.output_area div.output_text pre {\n", - " --txbk-content-mono-font-family: var(--txbk-code-font-family);\n", - "\n", - " font-weight: normal;\n", - " word-break: normal;\n", - " word-wrap: break-word;\n", - "}\n", - "\n", - "/* Output Standard Error */\n", - "div.output_stderr {\n", - " background-color: #FFFFFF;\n", - "}\n", - "\n", - "div.out_prompt_overlay:hover {\n", - " box-shadow: none;\n", - " background: none;\n", - "}\n", - "\n", - "/* Output HTML after cell code - e.g. Pandas DataFrame */\n", - "div.output_html {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "div.output_html a, div.output_html a:hover {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "div.output_html {\n", - " font-size: 1.4em;\n", - " font-weight: normal;\n", - " font-family: var(--txbk-code-font-family);\n", - "}\n", - "\n", - "div.output_html .nomono {\n", - " font-family: var(--txbk-content-font-family);\n", - " margin-top: 0;\n", - " font-size: 1em;\n", - "}\n", - "\n", - "div.output_html > iframe, div.output_area {\n", - " margin-left: 2rem;\n", - "}\n", - "\n", - "div.output_subarea {\n", - " margin-left: 0;\n", - "}\n", - "\n", - "div.output_svg div {\n", - " max-width: 98%;\n", - " margin-left: 0 !important;\n", - "}\n", - "\n", - "/* ----------------------------\n", - " Override default CSS rules\n", - " ---------------------------- */\n", - ".rendered_html code {\n", - " background-color: transparent !important;\n", - "}\n", - "\n", - ".rendered_html h1:first-child,\n", - ".rendered_html h2:first-child,\n", - ".rendered_html h3:first-child,\n", - ".rendered_html h4:first-child,\n", - ".rendered_html h5:first-child,\n", - ".rendered_html h6:first-child {\n", - " margin-top: 0.25em;\n", - "}\n", - "\n", - ".rendered_html h1 {\n", - " margin-top: 0.48em;\n", - "}\n", - "\n", - ".rendered_html h2 {\n", - " margin-top: 0.57em;\n", - "}\n", - "\n", - ".rendered_html h3 {\n", - " margin-top: 0.85em;\n", - "}\n", - "\n", - ".rendered_html h4 {\n", - " margin-top: 1.3em;\n", - "}\n", - "\n", - ".rendered_html h5 {\n", - " margin-top: 1.2em;\n", - "}\n", - "\n", - ".rendered_html h6 {\n", - " margin-top: 1.1em;\n", - "}\n", - "\n", - "/* ===============\n", - " CELLS Render\n", - " =============== */\n", - "\n", - "/* -------------------------\n", - " (1) CODE CELLS\n", - " Display + Edit modes\n", - " -------------------------\n", - "*/\n", - "div.code_cell pre, div.CodeMirror, div.CodeMirror-linenumber {\n", - " font-family: var(--txbk-code-font-family);\n", - " font-size: var(--txbk-code-font-size);\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - "div.CodeMirror-linenumber {\n", - " --txbk-ui-mono-font-size: 12px !important;\n", - "}\n", - "\n", - "/* -- MARKDOWN CELLS (Edit) -- */\n", - "\n", - "/* md cell */\n", - "div.text_cell.unrendered pre {\n", - " /* general font rule */\n", - " font-family: var(--txbk-md-font-family);\n", - " font-size: var(--txbk-md-font-size);\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - "/* md cell headers (edit) */\n", - ".cm-header-1, .cm-header-2, .cm-header-3,\n", - ".cm-header-4, .cm-header-5, .cm-header-6 {\n", - " /* general font rule */\n", - " font-family: var(--txbk-md-font-family);\n", - "}\n", - "\n", - "/* ------------------------------------------------------------------\n", - " (2) MARKDOWN CELLS (DISPLAY MODE)\n", - "\n", - " Notes: Font-families to use here:\n", - " computer-modern --> general text (Computer Modern Typeface, CMU)\n", - " md-display-monospace --> Monospace output (CMU Typewriter)\n", - " ------------------------------------------------------------------\n", - " */\n", - "\n", - "div.text_cell_render {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-size: var(--txbk-content-font-size);\n", - " color: var(--txbk-content-color);\n", - " font-kerning: auto;\n", - " text-align: justify;\n", - " display: block;\n", - " word-break: normal;\n", - " word-wrap: break-word;\n", - "}\n", - "\n", - "div.text_cell_render a, div.text_cell_render a:hover {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "div.text_cell_render h1, div.text_cell_render h2,\n", - "div.text_cell_render h3, div.text_cell_render h4,\n", - "div.text_cell_render h5, div.text_cell_render h6 {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Font-sizes for headers */\n", - "div.text_cell_render h1 {\n", - " font-size: 2.2em;\n", - " text-align: center;\n", - " padding-top: 3rem;\n", - " padding-bottom: 3rem;\n", - "}\n", - "\n", - "div.text_cell_render h2 {\n", - " font-size: 1.9em;\n", - "}\n", - "\n", - "div.text_cell_render h3 {\n", - " font-size: 1.7em;\n", - "}\n", - "\n", - "div.text_cell_render h4 {\n", - " font-size: 1.5em;\n", - "}\n", - "\n", - "div.text_cell_render h5 {\n", - " font-size: 1.3em;\n", - " border-bottom: 1px solid rgb(204, 204, 204);\n", - "}\n", - "\n", - "div.text_cell_render h6 {\n", - " font-size: 1.1em;\n", - "}\n", - "\n", - "div.text_cell_render p,\n", - "div.text_cell_render pre,\n", - "div.text_cell_render code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "div.text_cell_render pre,\n", - "div.text_cell_render code {\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "/* Monospace Code - no code syntax highlight*/\n", - "div.text_cell_render pre {\n", - " /* hack: using code background colour here to allow for compatibility */\n", - " background-color: var(--code-background-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "div.text_cell_render p {\n", - " line-height: var(--txbk-content-line-height);\n", - " text-align: justify !important;\n", - "}\n", - "\n", - "div.text_cell_render code {\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "/* Monospace inline rendered markdown */\n", - "div.text_cell_render p code {\n", - " /*Re-defining variables for Mono using Code Editor's settings*/\n", - " /*--txbk-content-mono-font-family: var(--txbk-code-font-family);*/\n", - " /*--txbk-content-mono-font-size: var(--txbk-code-font-size);*/\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "div.text_cell_render p strong code {\n", - " font-weight: bold !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "div.text_cell_render p em code {\n", - " font-style: italic !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "div.text_cell_render pre code {\n", - " padding: 1rem 1.5rem;\n", - " display: block !important;\n", - " color: var(--txbk-content-mono-color);\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " word-wrap: break-word;\n", - " word-break: normal;\n", - "}\n", - "\n", - "div.text_cell_render blockquote {\n", - " --txbk-ui-color: #6f6f6f;\n", - " margin: .2rem .2rem;\n", - " padding: .3rem .5rem;\n", - " border-left: .3rem solid #a7a7a7;\n", - " background-color: var(--txbk-content-mono-bgcolor);\n", - "}\n", - "\n", - "div.text_cell_render blockquote:not(:first-child) {\n", - " margin: 2rem .2rem;\n", - "}\n", - "\n", - "div.text_cell_render blockquote p {\n", - " padding: .2rem 1.5rem;\n", - "}\n", - "\n", - "div.text_cell_render table {\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " border-collapse: collapse;\n", - " border-spacing: 0;\n", - " overflow: auto;\n", - " break-inside: auto;\n", - " margin-top: 25px;\n", - " margin-bottom: 15px;\n", - "}\n", - "\n", - "div.text_cell_render table thead {\n", - " display: table-header-group;\n", - " vertical-align: middle;\n", - " border-bottom: none;\n", - "}\n", - "\n", - "div.text_cell_render table thead tr,\n", - "div.text_cell_render table thead tr th,\n", - "div.text_cell_render table thead tr td,\n", - "div.text_cell_render table tbody tr,\n", - "div.text_cell_render table tbody tr th,\n", - "div.text_cell_render table tbody tr td {\n", - " break-inside: avoid;\n", - " break-after: auto;\n", - " vertical-align: middle;\n", - " padding: 5px 5px;\n", - "}\n", - "\n", - "div.text_cell_render table tr th {\n", - " border-bottom-width: 0;\n", - "}\n", - "\n", - "div.text_cell_render ul, div.text_cell_render ol {\n", - " position: relative;\n", - " display: block;\n", - " margin-bottom: 0 !important;\n", - " line-height: var(--txbk-content-line-height);\n", - "}\n", - "\n", - "div.text_cell_render ul {\n", - " list-style-type: disc;\n", - "}\n", - "\n", - "div.text_cell_render ul li, div.text_cell_render ol li {\n", - " padding: .25em;\n", - "}\n", - "\n", - "div.text_cell_render ul ul {\n", - " list-style-type: circle !important;\n", - "}\n", - "\n", - "div.text_cell_render ul li > ul li a code,\n", - "div.text_cell_render ul li > ol li a code,\n", - "div.text_cell_render ol li > ul li a code,\n", - "div.text_cell_render ol li > ol li a code {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "div.text_cell_render ul ul ul {\n", - " list-style-type: square !important;\n", - "}\n", - "\n", - "div.text_cell_render p > img:only-child {\n", - " display: block;\n", - " margin: auto;\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - "div.text_cell_render img {\n", - " max-width: 70%;\n", - "}\n", - "\n", - "/*\n", - " ===================================\n", - " New CSS Classes and Styles\n", - " ===================================\n", - "\n", - " --------------\n", - " 1. Footnotes\n", - " --------------\n", - "*/\n", - "[id^='fn'], [class^='fn'] {\n", - " font-size: small !important;\n", - " font-weight: normal !important;\n", - " font-style: normal !important;\n", - " border-top: 1px solid var(--txbk-ui-mono-color);\n", - " padding-top: .8rem;\n", - " display: block;\n", - "}\n", - "\n", - "p > [id^='fn']:not(:first-child),\n", - "p > [class^='fn']:not(:first-child) {\n", - " border-top: 0 !important;\n", - "}\n", - "\n", - "[id^='fn'] i, [class^='fn'] i,\n", - "[id^='fn'] b, [class^='fn'] b,\n", - "[id^='fn'] strong, [class^='fn'] strong,\n", - "p > strong > strong {\n", - " background-color: var(--txbk-content-mono-bgcolor);\n", - " font-style: normal !important;\n", - " font-weight: bold !important;\n", - "}\n", - "\n", - "/* FIX Forcing monospace code to adhere with footnotes rules!*/\n", - "div.text_cell_render p [id^='fn'] > code,\n", - "div.text_cell_render p [class^='fn'] > code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "/* CSS Anchors link as superscript (like footnotes) */\n", - "a[href^=\"#fn\"], a[href*=\"fn\"] {\n", - " font-size: 60%;\n", - " vertical-align: top;\n", - "}\n", - "/* Surround Footnotes by Square brackets */\n", - "a[href^=\"#fn\"]:before, a[href*=\"fn\"]:before {\n", - " content: \"[\";\n", - "}\n", - "\n", - "a[href^=\"#fn\"]:after, a[href*=\"fn\"]:after {\n", - " content: \"]\";\n", - "}\n", - "\n", - "/* --------------\n", - " 2. Drop cap\n", - " --------------\n", - "*/\n", - ".drop {\n", - " color: var(--drop-cap-color);\n", - " font-size: 75px;\n", - " line-height: 60px;\n", - " padding-top: 4px;\n", - " margin-top: 0.2rem;\n", - "}\n", - "\n", - "/* -----------------------------\n", - " 3. noTeXbook Text colours\n", - " -----------------------------\n", - "*/\n", - ".texbook-red {\n", - " color: var(--texbook-red);\n", - "}\n", - "\n", - ".texbook-pink {\n", - " color: var(--texbook-pink);\n", - "}\n", - "\n", - ".texbook-turquoise {\n", - " color: var(--texbook-turquoise);\n", - "}\n", - "\n", - ".texbook-azure {\n", - " color: var(--texbook-azure);\n", - "}\n", - "\n", - ".texbook-blue {\n", - " color: var(--texbook-blue);\n", - "}\n", - "\n", - ".texbook-light-grey {\n", - " color: var(--texbook-light-grey);\n", - "}\n", - "\n", - ".texbook-dark-grey {\n", - " color: var(--texbook-dark-grey);\n", - "}\n", - "\n", - ".texbook-orange {\n", - " color: var(--texbook-orange);\n", - "}\n", - "\n", - ".texbook-yellow {\n", - " color: var(--texbook-yellow);\n", - "}\n", - "\n", - "/* ---------------------------------------------------------\n", - " 4. IMG MaxWidthXX\n", - "\n", - " CSS classes to control the max-width property of images\n", - " when the default 70% is not enough.\n", - " This is when images need to be enlarged or shrunk.\n", - " ---------------------------------------------------------\n", - "*/\n", - "\n", - "div.text_cell_render img.maxw10,\n", - "div.text_cell_render p > img.maxw10 {\n", - " max-width: 10% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw15,\n", - "div.text_cell_render p > img.maxw15 {\n", - " max-width: 15% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw20,\n", - "div.text_cell_render p > img.maxw20 {\n", - " max-width: 20% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw25,\n", - "div.text_cell_render p > img.maxw25 {\n", - " max-width: 25% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw30,\n", - "div.text_cell_render p > img.maxw30 {\n", - " max-width: 30% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw35,\n", - "div.text_cell_render p > img.maxw35 {\n", - " max-width: 35% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw40,\n", - "div.text_cell_render p > img.maxw40 {\n", - " max-width: 40% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw45,\n", - "div.text_cell_render p > img.maxw45 {\n", - " max-width: 45% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw50,\n", - "div.text_cell_render p > img.maxw50 {\n", - " max-width: 50% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw55,\n", - "div.text_cell_render p > img.maxw55 {\n", - " max-width: 55% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw60,\n", - "div.text_cell_render p > img.maxw60 {\n", - " max-width: 60% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw65,\n", - "div.text_cell_render p > img.maxw65 {\n", - " max-width: 65% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw70,\n", - "div.text_cell_render p > img.maxw70 {\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw75,\n", - "div.text_cell_render p > img.maxw75 {\n", - " max-width: 75% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw80,\n", - "div.text_cell_render p > img.maxw80 {\n", - " max-width: 80% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw85,\n", - "div.text_cell_render p > img.maxw85 {\n", - " max-width: 85% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw90,\n", - "div.text_cell_render p > img.maxw90 {\n", - " max-width: 90% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw95,\n", - "div.text_cell_render p > img.maxw95 {\n", - " max-width: 95% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw100,\n", - "div.text_cell_render p > img.maxw100 {\n", - " max-width: 100% !important;\n", - "}\n", - "\n", - "/* ------------\n", - " 4. Badges\n", - " ------------\n", - "*/\n", - ".badges img, .badges p img {\n", - " margin: 0 !important; /* Override margins */\n", - " display: inline !important;\n", - " padding-right: 7px;\n", - "}\n", - "\n", - ".badges p {\n", - " display: inline !important;\n", - "}\n", - "\n", - ".badges {\n", - " display: block;\n", - " text-align: center;\n", - "}\n", - "\n", - "/* ----------------\n", - " 5. Inline Math\n", - " ----------------\n", - "*/\n", - ".inline-math {\n", - " display: inline-block;\n", - "}\n", - "\n", - "/* --------------------\n", - " 6. Inline Mono Font\n", - " --------------------\n", - "*/\n", - ".codemono code, .codemono pre, .codemono pre code {\n", - " font-family: var(--txbk-code-font-family) !important;\n", - "}\n", - "\n", - ".mdmono code, .mdmono pre, .mdmono pre code {\n", - " font-family: var(--txbk-md-font-family) !important;\n", - "}\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " The notebook is using\n", - " \n", - " no$\\TeX$book Jupyter Theme (release 2.0.1).\n", - "\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Optional: setup NoTexBook theme\n", - "%load_ext notexbook\n", - "\n", - "%texify" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "dd85bfdc-ea55-4413-ac29-eddd6dab96ca", - "metadata": {}, - "outputs": [], - "source": [ - "# UNCOMMENT THIS ONLY if running on Anaconda Notebooks and if needed\n", - "# Note: Same modules as in MIA Training notebooks!\n", - "\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/dataset.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/models.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/train.py" - ] - }, - { - "cell_type": "markdown", - "id": "3ba8845d-8556-402d-a2fc-52d8b4e3dc2b", - "metadata": {}, - "source": [ - "# Model Inversion Attack" - ] - }, - { - "cell_type": "markdown", - "id": "1c67e4d2", - "metadata": {}, - "source": [ - "In this notebook we will be performing the **Model Inversion Attack** considering two pre-trained ML models as originally described in the reference paper:\n", - "\n", - "> **Model Inversion Attacks that Exploit Confidence Information and Basic Countermeasures**, by _Fredrikson, et. al_, 2015 \n", - "[DOI](https://dl.acm.org/doi/pdf/10.1145/2810103.2813677).\n", - "\n", - "The two models are `SoftmaxRegression` and `MLP`.\n", - "\n", - "⚠️ **Note**: All the experimental settings, and choices made in this notebook are _replicating_ exactly the original paper." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "68655027", - "metadata": {}, - "outputs": [], - "source": [ - "import torch as th\n", - "import numpy as np\n", - "\n", - "from matplotlib import pyplot as plt\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1942bb1a", - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", - "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", - "from six.moves import urllib\n", - "\n", - "opener = urllib.request.build_opener()\n", - "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", - "urllib.request.install_opener(opener)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "44bf0bd8", - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "import os\n", - "\n", - "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "45779d5a", - "metadata": {}, - "outputs": [], - "source": [ - "from dataset import ORLFaces\n", - "from torchvision.transforms import ToTensor" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "4db6abf3", - "metadata": {}, - "outputs": [], - "source": [ - "orl_faces_train = ORLFaces(root=DATA_FOLDER, download=True, split=\"train\", transform=ToTensor())\n", - "orl_faces_test = ORLFaces(root=DATA_FOLDER, download=True, split=\"test\", transform=ToTensor())" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "d0d51644", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([280, 112, 92]), torch.Size([120, 112, 92]))" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "orl_faces_train.data.shape, orl_faces_test.data.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "859989b5", - "metadata": {}, - "outputs": [], - "source": [ - "from torch.utils.data import DataLoader\n", - "\n", - "train_loader = DataLoader(orl_faces_train, batch_size=32, shuffle=False, drop_last=False)" - ] - }, - { - "cell_type": "markdown", - "id": "cd8754dc", - "metadata": {}, - "source": [ - "## Reconstruction Attack\n", - "\n", - "#### Settings" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c8c16f84", - "metadata": {}, - "outputs": [], - "source": [ - "# Reconstruction Attack Settings\n", - "# See Paper, Section 5.2 - Reconstruction Attack\n", - "α = 5000 # total iterations\n", - "β = 100 # max nr. of iterations without improvements\n", - "γ = 0.99 # threshold of the cost \n", - "λ = 0.1 # learning rate" - ] - }, - { - "cell_type": "markdown", - "id": "b7b97e4a", - "metadata": {}, - "source": [ - "#### Load Pre-trained Models" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "39426d25", - "metadata": {}, - "outputs": [], - "source": [ - "from models import SoftmaxRegression" - ] - }, - { - "cell_type": "markdown", - "id": "7b643a8f", - "metadata": {}, - "source": [ - "⚠️ If you skipped the **`MIA-Training`** notebook, please download the **pre-trained** weights of the `SoftmaxRegression` model here: [softmax_regression_mia.pt](https://www.dropbox.com/s/t9wglqyj5zr74fq/softmax_mia.pt?dl=1) and save it into the local `checkpoints` folder\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "34de5f7f", - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path \n", - "\n", - "CHECKPOINT_FOLDER = Path(\"./checkpoints/\")\n", - "CHECKPOINT_FOLDER.mkdir(exist_ok=True)\n", - "\n", - "def load_weights(model, model_filename: str = None):\n", - " if model_filename is None or not model_filename:\n", - " model_filename = f\"{model.__class__.__name__.lower()}.pt\"\n", - " w_file = CHECKPOINT_FOLDER / model_filename\n", - " try:\n", - " weights = th.load(open(w_file, \"rb\"))\n", - " except FileNotFoundError: \n", - " print(f\"Model Weights file {w_file} does not exist! Please check.\")\n", - " return None\n", - " return weights\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "d37c65ad", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "SoftmaxRegression(\n", - " (regression): Linear(in_features=10304, out_features=40, bias=True)\n", - ")" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "softmax_reg = SoftmaxRegression()\n", - "weights = load_weights(softmax_reg, model_filename=\"softmax_mia.pt\")\n", - "if weights is not None:\n", - " softmax_reg.load_state_dict(weights)\n", - " \n", - "softmax_reg" - ] - }, - { - "cell_type": "markdown", - "id": "ba0018ae", - "metadata": {}, - "source": [ - "## MIA Reconstruction Strategy\n", - "\n", - "\n", - "\"MIA" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "81e83c5b", - "metadata": {}, - "outputs": [], - "source": [ - "def process(im_flatten):\n", - " max_v = th.max(im_flatten)\n", - " min_v = th.min(im_flatten)\n", - " return (im_flatten-min_v) / (max_v - min_v)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e52a0ac1", - "metadata": {}, - "outputs": [], - "source": [ - "def mi_face(model, target_label):\n", - " aim_tensor = th.zeros(1, 112*92)\n", - " aim_tensor.requires_grad = True\n", - " \n", - " lossn_1 = 10\n", - " b = 0\n", - " g = 0\n", - " \n", - " out = model(aim_tensor.detach())\n", - " _, pred = th.max(out, 1)\n", - " print(pred)\n", - " print(f'original input image {target_label}')\n", - " plt.imshow(np.transpose(aim_tensor.detach().reshape(1, 112, 92).numpy(), (1, 2, 0)), cmap=\"Greys\")\n", - " plt.show()\n", - " print(f'original input image predict label {target_label} - predict label: {pred.item()}')\n", - " \n", - " criterion = th.nn.NLLLoss()\n", - " \n", - " for i in range(α):\n", - " out = model(aim_tensor)\n", - " if aim_tensor.grad is not None:\n", - " aim_tensor.grad.zero_()\n", - " out = out.reshape(1, 40)\n", - " target_class = th.tensor([target_label])\n", - " loss = criterion(out, target_class)\n", - " loss.backward()\n", - " aim_grad = aim_tensor.grad\n", - " \n", - " # SGD Step\n", - " # see https://pytorch.org/docs/stable/generated/torch.optim.SGD.html#torch.optim.SGD\n", - " aim_tensor = aim_tensor - (λ * aim_grad)\n", - " aim_tensor = process(aim_tensor)\n", - " aim_tensor = th.clamp(aim_tensor.detach(), 0, 1)\n", - " aim_tensor.requires_grad = True\n", - " if loss >= lossn_1:\n", - " b += 1\n", - " if b > β:\n", - " break\n", - " else:\n", - " b = 0\n", - " lossn_1 = loss\n", - " if loss < γ:\n", - " break\n", - " \n", - " print(f\"Attack completed at {i} iterations\")\n", - " out = model(aim_tensor.detach())\n", - " _, pred = th.max(out, 1)\n", - " print(pred)\n", - " print(f'inverted image {target_label}')\n", - " plt.imshow(np.transpose(aim_tensor.detach().reshape(1, 112, 92).numpy() * 255, (1, 2, 0)), cmap=\"Greys\")\n", - " plt.show()\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "44013f2f", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWcAAAGhCAYAAAC9CXUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAZcUlEQVR4nO3cf2zVV/3H8delhUuL7XVAuJcrP1aSJsDKHCuT2OFaw6hxOCXE/YJtLDOGWdi4q65QmY4RuRdQkbg6CMQwDCLECIrGH9RNy7AqXbdurDPgsgqVcVOn9d4yulbo+f5B+OR7V3DM3XLft30+kvvHPZ/T23dPyHOf3d7U55xzAgCYMizTAwAA+iPOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYFBG4/z000+rqKhII0eOVGlpqZ5//vlMjgMAZmQsznv37lUkEtHq1av10ksv6ROf+IQ+/elP6+TJk5kaCQDM8GXqDx/Nnj1bN954o7Zs2eKtTZs2TQsWLFAsFvuvX9vX16c333xTBQUF8vl8Az0qAKSNc05dXV0Kh8MaNuzy98e5V3EmT29vr5qbm7Vq1aqU9crKSjU2Nvbb39PTo56eHu/5qVOnNH369AGfEwAGSnt7uyZMmHDZ6xmJ81tvvaXz588rGAymrAeDQcXj8X77Y7GYnnzyyX7r7e3tKiwsHLA5ASDdksmkJk6cqIKCgv+6LyNxvujdb0k45y75NkVtba2qq6u95xd/uMLCQuIMICu911uyGYnz2LFjlZOT0+8uuaOjo9/dtCT5/X75/f6rNR4AZFxGPq0xYsQIlZaWqr6+PmW9vr5eZWVlmRgJAEzJ2Nsa1dXVuu+++zRr1ix9/OMf17Zt23Ty5Ek99NBDmRoJAMzIWJzvuusu/fOf/9TatWt1+vRplZSU6Je//KUmT56cqZEAwIyMfc75g0gmkwoEAkokEvxCEEBWudJ+8bc1AMAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudYLKabbrpJBQUFGjdunBYsWKBjx46l7HHOac2aNQqHw8rLy1NFRYVaW1vTPQoAZK20x7mhoUHLli3Tn/70J9XX1+vcuXOqrKzU22+/7e3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjk3kN/gH//4h8aNG6eGhgbdcsstcs4pHA4rEolo5cqVkqSenh4Fg0Ft2LBBS5cufc/XTCaTCgQCSiQSKiwsHMjxASCtrrRfA/6ecyKRkCSNHj1aktTW1qZ4PK7Kykpvj9/vV3l5uRobGy/5Gj09PUomkykPABjMBjTOzjlVV1drzpw5KikpkSTF43FJUjAYTNkbDAa9a+8Wi8UUCAS8x8SJEwdybADIuAGN8/Lly/XKK6/oRz/6Ub9rPp8v5blzrt/aRbW1tUokEt6jvb19QOYFACtyB+qFH374YR04cECHDh3ShAkTvPVQKCTpwh30+PHjvfWOjo5+d9MX+f1++f3+gRoVAMxJ+52zc07Lly/Xvn379Nxzz6moqCjlelFRkUKhkOrr67213t5eNTQ0qKysLN3jAEBWSvud87Jly7R792797Gc/U0FBgfc+ciAQUF5ennw+nyKRiKLRqIqLi1VcXKxoNKr8/HwtWrQo3eMAQFZKe5y3bNkiSaqoqEhZ37Fjhx544AFJUk1Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCsNOCfcx4IfM4ZQLYy8zlnAMD7R5wBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGDQgMc5FovJ5/MpEol4a845rVmzRuFwWHl5eaqoqFBra+tAjwIAWWNA49zU1KRt27bp+uuvT1nfuHGjNm3apLq6OjU1NSkUCmnevHnq6uoayHEAIGsMWJzPnDmjxYsXa/v27brmmmu8deecNm/erNWrV2vhwoUqKSnRzp07dfbsWe3evXugxgGArDJgcV62bJnmz5+vW2+9NWW9ra1N8XhclZWV3prf71d5ebkaGxsv+Vo9PT1KJpMpDwAYzHIH4kX37NmjF198UU1NTf2uxeNxSVIwGExZDwaDOnHixCVfLxaL6cknn0z/oABgVNrvnNvb27VixQrt2rVLI0eOvOw+n8+X8tw512/totraWiUSCe/R3t6e1pkBwJq03zk3Nzero6NDpaWl3tr58+d16NAh1dXV6dixY5Iu3EGPHz/e29PR0dHvbvoiv98vv9+f7lEBwKy03znPnTtXR48eVUtLi/eYNWuWFi9erJaWFk2ZMkWhUEj19fXe1/T29qqhoUFlZWXpHgcAslLa75wLCgpUUlKSsjZq1CiNGTPGW49EIopGoyouLlZxcbGi0ajy8/O1aNGidI8DAFlpQH4h+F5qamrU3d2tqqoqdXZ2avbs2Tp48KAKCgoyMQ4AmONzzrlMD/F+JZNJBQIBJRIJFRYWZnocALhiV9ov/rYGABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYNCAxPnUqVO69957NWbMGOXn5+uGG25Qc3Ozd905pzVr1igcDisvL08VFRVqbW0diFEAICulPc6dnZ26+eabNXz4cP3qV7/Sa6+9pm9/+9v68Ic/7O3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjmXzhdctWqV/vCHP+j555+/5HXnnMLhsCKRiFauXClJ6unpUTAY1IYNG7R06dL3/B7JZFKBQECJREKFhYXpHB8ABtSV9ivtd84HDhzQrFmzdMcdd2jcuHGaOXOmtm/f7l1va2tTPB5XZWWlt+b3+1VeXq7GxsZLvmZPT4+SyWTKAwAGs7TH+Y033tCWLVtUXFys3/zmN3rooYf0yCOP6Ac/+IEkKR6PS5KCwWDK1wWDQe/au8ViMQUCAe8xceLEdI8NAKakPc59fX268cYbFY1GNXPmTC1dulRf/OIXtWXLlpR9Pp8v5blzrt/aRbW1tUokEt6jvb093WMDgClpj/P48eM1ffr0lLVp06bp5MmTkqRQKCRJ/e6SOzo6+t1NX+T3+1VYWJjyAIDBLO1xvvnmm3Xs2LGUtePHj2vy5MmSpKKiIoVCIdXX13vXe3t71dDQoLKysnSPAwBZKTfdL/joo4+qrKxM0WhUd955p44cOaJt27Zp27Ztki68nRGJRBSNRlVcXKzi4mJFo1Hl5+dr0aJF6R4HALJS2uN80003af/+/aqtrdXatWtVVFSkzZs3a/Hixd6empoadXd3q6qqSp2dnZo9e7YOHjyogoKCdI8DAFkp7Z9zvhr4nDOAbJWxzzkDAD444gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudz587p8ccfV1FRkfLy8jRlyhStXbtWfX193h7nnNasWaNwOKy8vDxVVFSotbU13aMAQNZKe5w3bNigrVu3qq6uTn/5y1+0ceNGffOb39RTTz3l7dm4caM2bdqkuro6NTU1KRQKad68eerq6kr3OACQldIe5z/+8Y/63Oc+p/nz5+vaa6/V5z//eVVWVuqFF16QdOGuefPmzVq9erUWLlyokpIS7dy5U2fPntXu3bvTPQ4AZKW0x3nOnDl69tlndfz4cUnSyy+/rMOHD+u2226TJLW1tSkej6uystL7Gr/fr/LycjU2Nl7yNXt6epRMJlMeADCY5ab7BVeuXKlEIqGpU6cqJydH58+f17p163TPPfdIkuLxuCQpGAymfF0wGNSJEycu+ZqxWExPPvlkukcFALPSfue8d+9e7dq1S7t379aLL76onTt36lvf+pZ27tyZss/n86U8d871W7uotrZWiUTCe7S3t6d7bAAwJe13zo899phWrVqlu+++W5I0Y8YMnThxQrFYTEuWLFEoFJJ04Q56/Pjx3td1dHT0u5u+yO/3y+/3p3tUADAr7XfOZ8+e1bBhqS+bk5PjfZSuqKhIoVBI9fX13vXe3l41NDSorKws3eMAQFZK+53z7bffrnXr1mnSpEm67rrr9NJLL2nTpk168MEHJV14OyMSiSgajaq4uFjFxcWKRqPKz8/XokWL0j0OAGSltMf5qaee0te+9jVVVVWpo6ND4XBYS5cu1de//nVvT01Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCs5HPOuUwP8X4lk0kFAgElEgkVFhZmehwAuGJX2i/+tgYAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBg0PuO86FDh3T77bcrHA7L5/Pppz/9acp155zWrFmjcDisvLw8VVRUqLW1NWVPT0+PHn74YY0dO1ajRo3SZz/7Wf3973//QD8IAAwm7zvOb7/9tj760Y+qrq7uktc3btyoTZs2qa6uTk1NTQqFQpo3b566urq8PZFIRPv379eePXt0+PBhnTlzRp/5zGd0/vz5//0nAYDBxH0Aktz+/fu95319fS4UCrn169d7a++8844LBAJu69atzjnn/v3vf7vhw4e7PXv2eHtOnTrlhg0b5n79619f0fdNJBJOkkskEh9kfAC46q60X2l9z7mtrU3xeFyVlZXemt/vV3l5uRobGyVJzc3N+s9//pOyJxwOq6SkxNvzbj09PUomkykPABjM0hrneDwuSQoGgynrwWDQuxaPxzVixAhdc801l93zbrFYTIFAwHtMnDgxnWMDgDkD8mkNn8+X8tw512/t3f7bntraWiUSCe/R3t6etlkBwKK0xjkUCklSvzvgjo4O7246FAqpt7dXnZ2dl93zbn6/X4WFhSkPABjM0hrnoqIihUIh1dfXe2u9vb1qaGhQWVmZJKm0tFTDhw9P2XP69Gm9+uqr3h4AGOpy3+8XnDlzRq+//rr3vK2tTS0tLRo9erQmTZqkSCSiaDSq4uJiFRcXKxqNKj8/X4sWLZIkBQIBfeELX9CXv/xljRkzRqNHj9ZXvvIVzZgxQ7feemv6fjIAyGLvO84vvPCCPvnJT3rPq6urJUlLlizRM888o5qaGnV3d6uqqkqdnZ2aPXu2Dh48qIKCAu9rvvOd7yg3N1d33nmnuru7NXfuXD3zzDPKyclJw48EANnP55xzmR7i/UomkwoEAkokErz/DCCrXGm/+NsaAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwKDfTA/wvnHOSpGQymeFJAOD9uditix27nKyMc1dXlyRp4sSJGZ4EAP43XV1dCgQCl73uc++Vb4P6+vr05ptvyjmnSZMmqb29XYWFhZkeK2OSyaQmTpzIOXAOkjiHi6yeg3NOXV1dCofDGjbs8u8sZ+Wd87BhwzRhwgTvfw8KCwtNHX6mcA4XcA4XcA4XWDyH/3bHfBG/EAQAg4gzABiU1XH2+/164okn5Pf7Mz1KRnEOF3AOF3AOF2T7OWTlLwQBYLDL6jtnABisiDMAGEScAcAg4gwABmVtnJ9++mkVFRVp5MiRKi0t1fPPP5/pkQZULBbTTTfdpIKCAo0bN04LFizQsWPHUvY457RmzRqFw2Hl5eWpoqJCra2tGZr46ojFYvL5fIpEIt7aUDmHU6dO6d5779WYMWOUn5+vG264Qc3Nzd71oXAO586d0+OPP66ioiLl5eVpypQpWrt2rfr6+rw9WXsOLgvt2bPHDR8+3G3fvt299tprbsWKFW7UqFHuxIkTmR5twHzqU59yO3bscK+++qpraWlx8+fPd5MmTXJnzpzx9qxfv94VFBS4n/zkJ+7o0aPurrvucuPHj3fJZDKDkw+cI0eOuGuvvdZdf/31bsWKFd76UDiHf/3rX27y5MnugQcecH/+859dW1ub++1vf+tef/11b89QOIdvfOMbbsyYMe4Xv/iFa2trcz/+8Y/dhz70Ibd582ZvT7aeQ1bG+WMf+5h76KGHUtamTp3qVq1alaGJrr6Ojg4nyTU0NDjnnOvr63OhUMitX7/e2/POO++4QCDgtm7dmqkxB0xXV5crLi529fX1rry83IvzUDmHlStXujlz5lz2+lA5h/nz57sHH3wwZW3hwoXu3nvvdc5l9zlk3dsavb29am5uVmVlZcp6ZWWlGhsbMzTV1ZdIJCRJo0ePliS1tbUpHo+nnIvf71d5efmgPJdly5Zp/vz5uvXWW1PWh8o5HDhwQLNmzdIdd9yhcePGaebMmdq+fbt3faicw5w5c/Tss8/q+PHjkqSXX35Zhw8f1m233SYpu88h6/7w0VtvvaXz588rGAymrAeDQcXj8QxNdXU551RdXa05c+aopKREkryf/VLncuLEias+40Das2ePXnzxRTU1NfW7NlTO4Y033tCWLVtUXV2tr371qzpy5IgeeeQR+f1+3X///UPmHFauXKlEIqGpU6cqJydH58+f17p163TPPfdIyu5/D1kX54t8Pl/Kc+dcv7XBavny5XrllVd0+PDhftcG+7m0t7drxYoVOnjwoEaOHHnZfYP9HPr6+jRr1ixFo1FJ0syZM9Xa2qotW7bo/vvv9/YN9nPYu3evdu3apd27d+u6665TS0uLIpGIwuGwlixZ4u3LxnPIurc1xo4dq5ycnH53yR0dHf3+6zgYPfzwwzpw4IB+97vfacKECd56KBSSpEF/Ls3Nzero6FBpaalyc3OVm5urhoYGffe731Vubq73sw72cxg/frymT5+esjZt2jSdPHlS0tD59/DYY49p1apVuvvuuzVjxgzdd999evTRRxWLxSRl9zlkXZxHjBih0tJS1dfXp6zX19errKwsQ1MNPOecli9frn379um5555TUVFRyvWioiKFQqGUc+nt7VVDQ8OgOpe5c+fq6NGjamlp8R6zZs3S4sWL1dLSoilTpgyJc7j55pv7fZTy+PHjmjx5sqSh8+/h7Nmz/f5gfU5OjvdRuqw+hwz+MvJ/dvGjdN///vfda6+95iKRiBs1apT729/+lunRBsyXvvQlFwgE3O9//3t3+vRp73H27Flvz/r1610gEHD79u1zR48edffcc09WfGTog/r/n9Zwbmicw5EjR1xubq5bt26d++tf/+p++MMfuvz8fLdr1y5vz1A4hyVLlriPfOQj3kfp9u3b58aOHetqamq8Pdl6DlkZZ+ec+973vucmT57sRowY4W688UbvI2WDlaRLPnbs2OHt6evrc0888YQLhULO7/e7W265xR09ejRzQ18l747zUDmHn//8566kpMT5/X43depUt23btpTrQ+EcksmkW7FihZs0aZIbOXKkmzJlilu9erXr6enx9mTrOfAnQwHAoKx7zxkAhgLiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEH/B9l3Kld+JNUoAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 0 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([0])\n", - "inverted image 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 1 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([1])\n", - "inverted image 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 2 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([2])\n", - "inverted image 2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 3 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([3])\n", - "inverted image 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 4 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([4])\n", - "inverted image 4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 5\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 5 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([5])\n", - "inverted image 5\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 6\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 6 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([6])\n", - "inverted image 6\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 7\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 7 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([7])\n", - "inverted image 7\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 8\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 8 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([8])\n", - "inverted image 8\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 9\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 9 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([9])\n", - "inverted image 9\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Let's try to reconstruct the data for the first 10 classes (i.e. faces)\n", - "for cl in range(10):\n", - " mi_face(softmax_reg, cl)" - ] - }, - { - "cell_type": "markdown", - "id": "2f14d689", - "metadata": {}, - "source": [ - "### Exercise: \n", - "\n", - "Write the code to try the **model inversion reconstruction** using the `MLP` model" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "3ad83641", - "metadata": {}, - "outputs": [], - "source": [ - "from models import MLP" - ] - }, - { - "cell_type": "markdown", - "id": "a3df4a1b", - "metadata": {}, - "source": [ - "⚠️ Grab the **pre-trained** weights of the `SoftmaxRegression` model here: [mlp_mia.pt](https://www.dropbox.com/s/8ul2lj2eqcykfxm/mlp_mia.pt?dl=1) and save it into the local `checkpoints` folder" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "58bab294", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "MLP(\n", - " (hidden): Linear(in_features=10304, out_features=3000, bias=True)\n", - " (prediction): Linear(in_features=3000, out_features=40, bias=True)\n", - ")" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mlp = MLP()\n", - "weights = load_weights(mlp, model_filename=\"mlp_mia.pt\")\n", - "if weights is not None:\n", - " mlp.load_state_dict(weights)\n", - "\n", - "mlp" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "76662b42", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 0 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([0])\n", - "inverted image 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 1 - predict label: 21\n", - "Attack completed at 140 iterations\n", - "tensor([1])\n", - "inverted image 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 2\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWcAAAGhCAYAAAC9CXUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAZcUlEQVR4nO3cf2zVV/3H8delhUuL7XVAuJcrP1aSJsDKHCuT2OFaw6hxOCXE/YJtLDOGWdi4q65QmY4RuRdQkbg6CMQwDCLECIrGH9RNy7AqXbdurDPgsgqVcVOn9d4yulbo+f5B+OR7V3DM3XLft30+kvvHPZ/T23dPyHOf3d7U55xzAgCYMizTAwAA+iPOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYFBG4/z000+rqKhII0eOVGlpqZ5//vlMjgMAZmQsznv37lUkEtHq1av10ksv6ROf+IQ+/elP6+TJk5kaCQDM8GXqDx/Nnj1bN954o7Zs2eKtTZs2TQsWLFAsFvuvX9vX16c333xTBQUF8vl8Az0qAKSNc05dXV0Kh8MaNuzy98e5V3EmT29vr5qbm7Vq1aqU9crKSjU2Nvbb39PTo56eHu/5qVOnNH369AGfEwAGSnt7uyZMmHDZ6xmJ81tvvaXz588rGAymrAeDQcXj8X77Y7GYnnzyyX7r7e3tKiwsHLA5ASDdksmkJk6cqIKCgv+6LyNxvujdb0k45y75NkVtba2qq6u95xd/uMLCQuIMICu911uyGYnz2LFjlZOT0+8uuaOjo9/dtCT5/X75/f6rNR4AZFxGPq0xYsQIlZaWqr6+PmW9vr5eZWVlmRgJAEzJ2Nsa1dXVuu+++zRr1ix9/OMf17Zt23Ty5Ek99NBDmRoJAMzIWJzvuusu/fOf/9TatWt1+vRplZSU6Je//KUmT56cqZEAwIyMfc75g0gmkwoEAkokEvxCEEBWudJ+8bc1AMAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudYLKabbrpJBQUFGjdunBYsWKBjx46l7HHOac2aNQqHw8rLy1NFRYVaW1vTPQoAZK20x7mhoUHLli3Tn/70J9XX1+vcuXOqrKzU22+/7e3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjk3kN/gH//4h8aNG6eGhgbdcsstcs4pHA4rEolo5cqVkqSenh4Fg0Ft2LBBS5cufc/XTCaTCgQCSiQSKiwsHMjxASCtrrRfA/6ecyKRkCSNHj1aktTW1qZ4PK7Kykpvj9/vV3l5uRobGy/5Gj09PUomkykPABjMBjTOzjlVV1drzpw5KikpkSTF43FJUjAYTNkbDAa9a+8Wi8UUCAS8x8SJEwdybADIuAGN8/Lly/XKK6/oRz/6Ub9rPp8v5blzrt/aRbW1tUokEt6jvb19QOYFACtyB+qFH374YR04cECHDh3ShAkTvPVQKCTpwh30+PHjvfWOjo5+d9MX+f1++f3+gRoVAMxJ+52zc07Lly/Xvn379Nxzz6moqCjlelFRkUKhkOrr67213t5eNTQ0qKysLN3jAEBWSvud87Jly7R792797Gc/U0FBgfc+ciAQUF5ennw+nyKRiKLRqIqLi1VcXKxoNKr8/HwtWrQo3eMAQFZKe5y3bNkiSaqoqEhZ37Fjhx544AFJUk1Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCsNOCfcx4IfM4ZQLYy8zlnAMD7R5wBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGDQgMc5FovJ5/MpEol4a845rVmzRuFwWHl5eaqoqFBra+tAjwIAWWNA49zU1KRt27bp+uuvT1nfuHGjNm3apLq6OjU1NSkUCmnevHnq6uoayHEAIGsMWJzPnDmjxYsXa/v27brmmmu8deecNm/erNWrV2vhwoUqKSnRzp07dfbsWe3evXugxgGArDJgcV62bJnmz5+vW2+9NWW9ra1N8XhclZWV3prf71d5ebkaGxsv+Vo9PT1KJpMpDwAYzHIH4kX37NmjF198UU1NTf2uxeNxSVIwGExZDwaDOnHixCVfLxaL6cknn0z/oABgVNrvnNvb27VixQrt2rVLI0eOvOw+n8+X8tw512/totraWiUSCe/R3t6e1pkBwJq03zk3Nzero6NDpaWl3tr58+d16NAh1dXV6dixY5Iu3EGPHz/e29PR0dHvbvoiv98vv9+f7lEBwKy03znPnTtXR48eVUtLi/eYNWuWFi9erJaWFk2ZMkWhUEj19fXe1/T29qqhoUFlZWXpHgcAslLa75wLCgpUUlKSsjZq1CiNGTPGW49EIopGoyouLlZxcbGi0ajy8/O1aNGidI8DAFlpQH4h+F5qamrU3d2tqqoqdXZ2avbs2Tp48KAKCgoyMQ4AmONzzrlMD/F+JZNJBQIBJRIJFRYWZnocALhiV9ov/rYGABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYNCAxPnUqVO69957NWbMGOXn5+uGG25Qc3Ozd905pzVr1igcDisvL08VFRVqbW0diFEAICulPc6dnZ26+eabNXz4cP3qV7/Sa6+9pm9/+9v68Ic/7O3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjmXzhdctWqV/vCHP+j555+/5HXnnMLhsCKRiFauXClJ6unpUTAY1IYNG7R06dL3/B7JZFKBQECJREKFhYXpHB8ABtSV9ivtd84HDhzQrFmzdMcdd2jcuHGaOXOmtm/f7l1va2tTPB5XZWWlt+b3+1VeXq7GxsZLvmZPT4+SyWTKAwAGs7TH+Y033tCWLVtUXFys3/zmN3rooYf0yCOP6Ac/+IEkKR6PS5KCwWDK1wWDQe/au8ViMQUCAe8xceLEdI8NAKakPc59fX268cYbFY1GNXPmTC1dulRf/OIXtWXLlpR9Pp8v5blzrt/aRbW1tUokEt6jvb093WMDgClpj/P48eM1ffr0lLVp06bp5MmTkqRQKCRJ/e6SOzo6+t1NX+T3+1VYWJjyAIDBLO1xvvnmm3Xs2LGUtePHj2vy5MmSpKKiIoVCIdXX13vXe3t71dDQoLKysnSPAwBZKTfdL/joo4+qrKxM0WhUd955p44cOaJt27Zp27Ztki68nRGJRBSNRlVcXKzi4mJFo1Hl5+dr0aJF6R4HALJS2uN80003af/+/aqtrdXatWtVVFSkzZs3a/Hixd6empoadXd3q6qqSp2dnZo9e7YOHjyogoKCdI8DAFkp7Z9zvhr4nDOAbJWxzzkDAD444gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudz587p8ccfV1FRkfLy8jRlyhStXbtWfX193h7nnNasWaNwOKy8vDxVVFSotbU13aMAQNZKe5w3bNigrVu3qq6uTn/5y1+0ceNGffOb39RTTz3l7dm4caM2bdqkuro6NTU1KRQKad68eerq6kr3OACQldIe5z/+8Y/63Oc+p/nz5+vaa6/V5z//eVVWVuqFF16QdOGuefPmzVq9erUWLlyokpIS7dy5U2fPntXu3bvTPQ4AZKW0x3nOnDl69tlndfz4cUnSyy+/rMOHD+u2226TJLW1tSkej6uystL7Gr/fr/LycjU2Nl7yNXt6epRMJlMeADCY5ab7BVeuXKlEIqGpU6cqJydH58+f17p163TPPfdIkuLxuCQpGAymfF0wGNSJEycu+ZqxWExPPvlkukcFALPSfue8d+9e7dq1S7t379aLL76onTt36lvf+pZ27tyZss/n86U8d871W7uotrZWiUTCe7S3t6d7bAAwJe13zo899phWrVqlu+++W5I0Y8YMnThxQrFYTEuWLFEoFJJ04Q56/Pjx3td1dHT0u5u+yO/3y+/3p3tUADAr7XfOZ8+e1bBhqS+bk5PjfZSuqKhIoVBI9fX13vXe3l41NDSorKws3eMAQFZK+53z7bffrnXr1mnSpEm67rrr9NJLL2nTpk168MEHJV14OyMSiSgajaq4uFjFxcWKRqPKz8/XokWL0j0OAGSltMf5qaee0te+9jVVVVWpo6ND4XBYS5cu1de//nVvT01Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCs5HPOuUwP8X4lk0kFAgElEgkVFhZmehwAuGJX2i/+tgYAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBg0PuO86FDh3T77bcrHA7L5/Pppz/9acp155zWrFmjcDisvLw8VVRUqLW1NWVPT0+PHn74YY0dO1ajRo3SZz/7Wf3973//QD8IAAwm7zvOb7/9tj760Y+qrq7uktc3btyoTZs2qa6uTk1NTQqFQpo3b566urq8PZFIRPv379eePXt0+PBhnTlzRp/5zGd0/vz5//0nAYDBxH0Aktz+/fu95319fS4UCrn169d7a++8844LBAJu69atzjnn/v3vf7vhw4e7PXv2eHtOnTrlhg0b5n79619f0fdNJBJOkkskEh9kfAC46q60X2l9z7mtrU3xeFyVlZXemt/vV3l5uRobGyVJzc3N+s9//pOyJxwOq6SkxNvzbj09PUomkykPABjM0hrneDwuSQoGgynrwWDQuxaPxzVixAhdc801l93zbrFYTIFAwHtMnDgxnWMDgDkD8mkNn8+X8tw512/t3f7bntraWiUSCe/R3t6etlkBwKK0xjkUCklSvzvgjo4O7246FAqpt7dXnZ2dl93zbn6/X4WFhSkPABjM0hrnoqIihUIh1dfXe2u9vb1qaGhQWVmZJKm0tFTDhw9P2XP69Gm9+uqr3h4AGOpy3+8XnDlzRq+//rr3vK2tTS0tLRo9erQmTZqkSCSiaDSq4uJiFRcXKxqNKj8/X4sWLZIkBQIBfeELX9CXv/xljRkzRqNHj9ZXvvIVzZgxQ7feemv6fjIAyGLvO84vvPCCPvnJT3rPq6urJUlLlizRM888o5qaGnV3d6uqqkqdnZ2aPXu2Dh48qIKCAu9rvvOd7yg3N1d33nmnuru7NXfuXD3zzDPKyclJw48EANnP55xzmR7i/UomkwoEAkokErz/DCCrXGm/+NsaAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwKDfTA/wvnHOSpGQymeFJAOD9uditix27nKyMc1dXlyRp4sSJGZ4EAP43XV1dCgQCl73uc++Vb4P6+vr05ptvyjmnSZMmqb29XYWFhZkeK2OSyaQmTpzIOXAOkjiHi6yeg3NOXV1dCofDGjbs8u8sZ+Wd87BhwzRhwgTvfw8KCwtNHX6mcA4XcA4XcA4XWDyH/3bHfBG/EAQAg4gzABiU1XH2+/164okn5Pf7Mz1KRnEOF3AOF3AOF2T7OWTlLwQBYLDL6jtnABisiDMAGEScAcAg4gwABmVtnJ9++mkVFRVp5MiRKi0t1fPPP5/pkQZULBbTTTfdpIKCAo0bN04LFizQsWPHUvY457RmzRqFw2Hl5eWpoqJCra2tGZr46ojFYvL5fIpEIt7aUDmHU6dO6d5779WYMWOUn5+vG264Qc3Nzd71oXAO586d0+OPP66ioiLl5eVpypQpWrt2rfr6+rw9WXsOLgvt2bPHDR8+3G3fvt299tprbsWKFW7UqFHuxIkTmR5twHzqU59yO3bscK+++qpraWlx8+fPd5MmTXJnzpzx9qxfv94VFBS4n/zkJ+7o0aPurrvucuPHj3fJZDKDkw+cI0eOuGuvvdZdf/31bsWKFd76UDiHf/3rX27y5MnugQcecH/+859dW1ub++1vf+tef/11b89QOIdvfOMbbsyYMe4Xv/iFa2trcz/+8Y/dhz70Ibd582ZvT7aeQ1bG+WMf+5h76KGHUtamTp3qVq1alaGJrr6Ojg4nyTU0NDjnnOvr63OhUMitX7/e2/POO++4QCDgtm7dmqkxB0xXV5crLi529fX1rry83IvzUDmHlStXujlz5lz2+lA5h/nz57sHH3wwZW3hwoXu3nvvdc5l9zlk3dsavb29am5uVmVlZcp6ZWWlGhsbMzTV1ZdIJCRJo0ePliS1tbUpHo+nnIvf71d5efmgPJdly5Zp/vz5uvXWW1PWh8o5HDhwQLNmzdIdd9yhcePGaebMmdq+fbt3faicw5w5c/Tss8/q+PHjkqSXX35Zhw8f1m233SYpu88h6/7w0VtvvaXz588rGAymrAeDQcXj8QxNdXU551RdXa05c+aopKREkryf/VLncuLEias+40Das2ePXnzxRTU1NfW7NlTO4Y033tCWLVtUXV2tr371qzpy5IgeeeQR+f1+3X///UPmHFauXKlEIqGpU6cqJydH58+f17p163TPPfdIyu5/D1kX54t8Pl/Kc+dcv7XBavny5XrllVd0+PDhftcG+7m0t7drxYoVOnjwoEaOHHnZfYP9HPr6+jRr1ixFo1FJ0syZM9Xa2qotW7bo/vvv9/YN9nPYu3evdu3apd27d+u6665TS0uLIpGIwuGwlixZ4u3LxnPIurc1xo4dq5ycnH53yR0dHf3+6zgYPfzwwzpw4IB+97vfacKECd56KBSSpEF/Ls3Nzero6FBpaalyc3OVm5urhoYGffe731Vubq73sw72cxg/frymT5+esjZt2jSdPHlS0tD59/DYY49p1apVuvvuuzVjxgzdd999evTRRxWLxSRl9zlkXZxHjBih0tJS1dfXp6zX19errKwsQ1MNPOecli9frn379um5555TUVFRyvWioiKFQqGUc+nt7VVDQ8OgOpe5c+fq6NGjamlp8R6zZs3S4sWL1dLSoilTpgyJc7j55pv7fZTy+PHjmjx5sqSh8+/h7Nmz/f5gfU5OjvdRuqw+hwz+MvJ/dvGjdN///vfda6+95iKRiBs1apT729/+lunRBsyXvvQlFwgE3O9//3t3+vRp73H27Flvz/r1610gEHD79u1zR48edffcc09WfGTog/r/n9Zwbmicw5EjR1xubq5bt26d++tf/+p++MMfuvz8fLdr1y5vz1A4hyVLlriPfOQj3kfp9u3b58aOHetqamq8Pdl6DlkZZ+ec+973vucmT57sRowY4W688UbvI2WDlaRLPnbs2OHt6evrc0888YQLhULO7/e7W265xR09ejRzQ18l747zUDmHn//8566kpMT5/X43depUt23btpTrQ+EcksmkW7FihZs0aZIbOXKkmzJlilu9erXr6enx9mTrOfAnQwHAoKx7zxkAhgLiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEH/B9l3Kld+JNUoAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 2 - predict label: 21\n", - "Attack completed at 175 iterations\n", - "tensor([2])\n", - "inverted image 2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 3 - predict label: 21\n", - "Attack completed at 67 iterations\n", - "tensor([3])\n", - "inverted image 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 4 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([4])\n", - "inverted image 4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 5\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 5 - predict label: 21\n", - "Attack completed at 1 iterations\n", - "tensor([5])\n", - "inverted image 5\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([21])\n", - "original input image 6\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 6 - predict label: 21\n" - ] - } - ], - "source": [ - "# Reconstruction Attack code HERE\n", - "for cl in range(10):\n", - " mi_face(mlp, cl)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/2-ml-models-attacks/2-MIA-Training.ipynb b/2-ml-models-attacks/2-MIA-Training.ipynb new file mode 100644 index 0000000..736db47 --- /dev/null +++ b/2-ml-models-attacks/2-MIA-Training.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "d4e39d12-6b19-451d-b1b9-2502d6f8e15a", + "metadata": {}, + "outputs": [], + "source": [ + "# Optional: setup NoTexBook theme\n", + "%load_ext notexbook\n", + "\n", + "%texify" + ] + }, + { + "cell_type": "markdown", + "id": "dcd69b34", + "metadata": {}, + "source": [ + "# Model Inversion Attack - Model Training" + ] + }, + { + "cell_type": "markdown", + "id": "85ed1933", + "metadata": {}, + "source": [ + "In this notebook we will be performing the training of **two** (out of three) of the ML models considered in the paper:\n", + "\n", + "> **Model Inversion Attacks that Exploit Confidence Information and Basic Countermeasures**, by _Fredrikson, et. al_, 2015 \n", + "[DOI](https://dl.acm.org/doi/pdf/10.1145/2810103.2813677).\n", + "\n", + "The two models are `SoftmaxRegression` and `MLP`.\n", + "\n", + "⚠️ **NOTE**: Please feel free to skip this notebook completely (if you don't want to **re-train** the models on your own) and jump directly to the next [MIA Reconstruction](./2-MIA-Reconstruction.ipynb) notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eee64647", + "metadata": {}, + "outputs": [], + "source": [ + "import torch as th\n", + "import numpy as np\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3126b393", + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", + "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", + "from six.moves import urllib\n", + "\n", + "opener = urllib.request.build_opener()\n", + "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", + "urllib.request.install_opener(opener)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9086c266", + "metadata": {}, + "outputs": [], + "source": [ + "from dataset import ORLFaces\n", + "from torchvision.transforms import ToTensor, Grayscale, Compose\n", + "from torch.utils.data import DataLoader" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbc48ffb", + "metadata": {}, + "outputs": [], + "source": [ + "# Reproducibility Settings\n", + "\n", + "SEED = 123456\n", + "\n", + "np.random.seed(SEED)\n", + "th.manual_seed(SEED)\n", + "if th.cuda.is_available():\n", + " th.cuda.manual_seed_all(SEED)\n", + " th.backends.cudnn.deterministic = True" + ] + }, + { + "cell_type": "markdown", + "id": "5dc0251e", + "metadata": {}, + "source": [ + "### The `ORLFaces` Dataset\n", + "\n", + "The original paper considers the **AT&T Face Database** faces dataset (which I have encapsualted and made available as a PyTorch `Dataset`): `ORLFaces`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "345e23a7", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import os\n", + "\n", + "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ee5718e", + "metadata": {}, + "outputs": [], + "source": [ + "print(DATA_FOLDER)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c16625ec", + "metadata": {}, + "outputs": [], + "source": [ + "imgs_trasform = Compose([Grayscale(num_output_channels=1), ToTensor()])\n", + "\n", + "orl_faces_train = ORLFaces(\n", + " root=DATA_FOLDER, download=True, split=\"train\", transform=imgs_trasform\n", + ")\n", + "orl_faces_test = ORLFaces(\n", + " root=DATA_FOLDER, download=True, split=\"test\", transform=imgs_trasform\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9ae6a51", + "metadata": {}, + "outputs": [], + "source": [ + "BATCH_SIZE = 32\n", + "\n", + "train_loader = DataLoader(\n", + " orl_faces_train, batch_size=BATCH_SIZE, shuffle=True, drop_last=False\n", + ")\n", + "test_loader = DataLoader(\n", + " orl_faces_test, batch_size=BATCH_SIZE, shuffle=False, drop_last=False\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "bd2b2a27", + "metadata": {}, + "source": [ + "#### A few notes about the dataset \n", + "\n", + "The `ORLFaces` dataset contains `400` image files corresponding to `40` different subjects (`10` photo each).\n", + "\n", + "\n", + "Images are `112x92` pixels, with `256` grey levels per pixel, and (originally) stored in `PGM` format.\n", + "The photos of the subjects have been taken at different times, are varying the lightning, the facial expressions\n", + " (e.g. open/closed eyes, smiling/serious face), and the facial details.\n", + "\n", + "**Train/Test** partitions have been generated similarly to what has been done in the original paper, that is: \n", + "\n", + "(for each subject):\n", + "\n", + "- Randomly pick $7$ (out of $10$) images of the subject and add them to the **training set**\n", + "- Add remaining $3$ images to the **test set**" + ] + }, + { + "cell_type": "markdown", + "id": "425c305c", + "metadata": {}, + "source": [ + "#### Visualise a few Samples in the Dataset\n", + "\n", + "Before we start with the training, let's visualise a few random samples extracted from the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61e794b9", + "metadata": {}, + "outputs": [], + "source": [ + "from torchvision.utils import make_grid\n", + "\n", + "\n", + "def imshow(img):\n", + " npimg = img.numpy()\n", + " plt.figure(figsize=(10, 12))\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aa210aaf", + "metadata": {}, + "outputs": [], + "source": [ + "# get some random training images\n", + "images, labels = next(iter(train_loader))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "089395c5", + "metadata": {}, + "outputs": [], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7dc07e43", + "metadata": {}, + "outputs": [], + "source": [ + "# show images\n", + "imshow(make_grid(images))\n", + "# print labels\n", + "print(\" \".join(f\"{labels[j]}\" for j in range(BATCH_SIZE)))" + ] + }, + { + "cell_type": "markdown", + "id": "2513010f", + "metadata": {}, + "source": [ + "ℹ️ **Note**: Do you see the **exact same faces** that are being displayed here? " + ] + }, + { + "cell_type": "markdown", + "id": "2b7b9841", + "metadata": {}, + "source": [ + "## Machine Learning Model Training\n", + "\n", + "In the original Paper, authors refer to three separated models used as reference examples for the Model Inversion Attack. \n", + "\n", + "Here to keep things simple, we will only consider two of them: `SoftmaxRegression` and `MLP`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0d1c795", + "metadata": {}, + "outputs": [], + "source": [ + "from models import SoftmaxRegression, MLP" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b14bbfe8", + "metadata": {}, + "outputs": [], + "source": [ + "from train import train" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a193ca3", + "metadata": {}, + "outputs": [], + "source": [ + "λ = 0.1 # optimiser learning rate, as used in the paper" + ] + }, + { + "cell_type": "markdown", + "id": "7b9d5e71", + "metadata": {}, + "source": [ + "#### Training `SoftmaxRegression`\n", + "\n", + "Note: This should be super-fast even on a laptop (small model, small data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62df081d", + "metadata": {}, + "outputs": [], + "source": [ + "softmax_reg = SoftmaxRegression()\n", + "softmax_sgd = th.optim.SGD(softmax_reg.parameters(), lr=λ)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb471d2d", + "metadata": {}, + "outputs": [], + "source": [ + "softmax_reg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4e0f0a2", + "metadata": {}, + "outputs": [], + "source": [ + "train(\n", + " model=softmax_reg,\n", + " optimiser=softmax_sgd,\n", + " loaders=(train_loader, test_loader),\n", + " model_name=\"softmax_mia\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d8acf454", + "metadata": {}, + "source": [ + "### Training `MLP`\n", + "\n", + "⚠️ **Note**: This may be a bit slower to train on a laptop (it shouldn't be that much, though!) \n", + "\n", + "If you notice that it is the case, please also feel free to skip this and jump at the end of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12c1109e", + "metadata": {}, + "outputs": [], + "source": [ + "mlp = MLP()\n", + "mlp_sgd = th.optim.SGD(mlp.parameters(), lr=λ)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53e40c39", + "metadata": {}, + "outputs": [], + "source": [ + "mlp" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "123b3abc", + "metadata": {}, + "outputs": [], + "source": [ + "train(\n", + " model=mlp,\n", + " optimiser=mlp_sgd,\n", + " loaders=(train_loader, test_loader),\n", + " model_name=\"mlp_mia\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c5646846", + "metadata": {}, + "source": [ + "### Congratulations\n", + "\n", + "**Well done** 🎉\n", + "\n", + "Now that we have our two reference **trained** model, we are ready to setup and launch the _model inversion_ attack to the model. \n", + "\n", + "$\\rightarrow$ **MIA Reconstruction**" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/2-ml-models-attacks/3-Introducing-OPACUS.ipynb b/2-ml-models-attacks/3-Introducing-OPACUS.ipynb deleted file mode 100644 index 2a8bcbc..0000000 --- a/2-ml-models-attacks/3-Introducing-OPACUS.ipynb +++ /dev/null @@ -1,3151 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "
\n", - " The notebook is using\n", - " \n", - " no$\\TeX$book Jupyter Theme (release 2.0.1).\n", - "\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Optional: setup NoTexBook theme\n", - "%load_ext notexbook\n", - "\n", - "%texify" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Introducing Opacus\n", - "\n", - "![](https://opacus.ai/img/opacus_logo_vertical.svg)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[Opacus](https://opacus.ai/) is the framework in the PyTorch ecosystem that brings **Differential Privacy** to (PyTorch) Model Training" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "(from [Introducing Opacus](https://ai.facebook.com/blog/introducing-opacus-a-high-speed-library-for-training-pytorch-models-with-differential-privacy/))\n", - "\n", - " \n", - "> `Opacus` (_is_) a new high-speed library for training PyTorch models with differential privacy (DP) that’s more scalable than existing state-of-the-art methods. \n", - ">\n", - "> Differential privacy is a mathematically rigorous framework for quantifying the anonymization of sensitive data. \n", - ">\n", - "> It’s often used in analytics, with growing interest in the machine learning (ML) community. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's have a look at how `Opacus` effectively integrated DP (i.e. `DP-SGD`)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/2-ml-models-attacks/3-MIA-Reconstruction.ipynb b/2-ml-models-attacks/3-MIA-Reconstruction.ipynb new file mode 100644 index 0000000..4945f8e --- /dev/null +++ b/2-ml-models-attacks/3-MIA-Reconstruction.ipynb @@ -0,0 +1,393 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "5f01a093-5560-4e09-a9c3-95c097fdbcb6", + "metadata": {}, + "outputs": [], + "source": [ + "# Optional: setup NoTexBook theme\n", + "%load_ext notexbook\n", + "\n", + "%texify" + ] + }, + { + "cell_type": "markdown", + "id": "3ba8845d-8556-402d-a2fc-52d8b4e3dc2b", + "metadata": {}, + "source": [ + "# Model Inversion Attack" + ] + }, + { + "cell_type": "markdown", + "id": "1c67e4d2", + "metadata": {}, + "source": [ + "In this notebook we will be performing the **Model Inversion Attack** considering two pre-trained ML models as originally described in the reference paper:\n", + "\n", + "> **Model Inversion Attacks that Exploit Confidence Information and Basic Countermeasures**, by _Fredrikson, et. al_, 2015 \n", + "[DOI](https://dl.acm.org/doi/pdf/10.1145/2810103.2813677).\n", + "\n", + "The two models are `SoftmaxRegression` and `MLP`.\n", + "\n", + "⚠️ **Note**: All the experimental settings, and choices made in this notebook are _replicating_ exactly the original paper." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68655027", + "metadata": {}, + "outputs": [], + "source": [ + "import torch as th\n", + "import numpy as np\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1942bb1a", + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", + "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", + "from six.moves import urllib\n", + "\n", + "opener = urllib.request.build_opener()\n", + "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", + "urllib.request.install_opener(opener)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44bf0bd8", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import os\n", + "\n", + "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45779d5a", + "metadata": {}, + "outputs": [], + "source": [ + "from dataset import ORLFaces\n", + "from torchvision.transforms import ToTensor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4db6abf3", + "metadata": {}, + "outputs": [], + "source": [ + "orl_faces_train = ORLFaces(root=DATA_FOLDER, download=True, split=\"train\", transform=ToTensor())\n", + "orl_faces_test = ORLFaces(root=DATA_FOLDER, download=True, split=\"test\", transform=ToTensor())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0d51644", + "metadata": {}, + "outputs": [], + "source": [ + "orl_faces_train.data.shape, orl_faces_test.data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "859989b5", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "train_loader = DataLoader(orl_faces_train, batch_size=32, shuffle=False, drop_last=False)" + ] + }, + { + "cell_type": "markdown", + "id": "cd8754dc", + "metadata": {}, + "source": [ + "## Reconstruction Attack\n", + "\n", + "#### Settings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8c16f84", + "metadata": {}, + "outputs": [], + "source": [ + "# Reconstruction Attack Settings\n", + "# See Paper, Section 5.2 - Reconstruction Attack\n", + "α = 5000 # total iterations\n", + "β = 100 # max nr. of iterations without improvements\n", + "γ = 0.99 # threshold of the cost \n", + "λ = 0.1 # learning rate" + ] + }, + { + "cell_type": "markdown", + "id": "b7b97e4a", + "metadata": {}, + "source": [ + "#### Load Pre-trained Models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39426d25", + "metadata": {}, + "outputs": [], + "source": [ + "from models import SoftmaxRegression" + ] + }, + { + "cell_type": "markdown", + "id": "7b643a8f", + "metadata": {}, + "source": [ + "⚠️ If you skipped the **`MIA-Training`** notebook, please download the **pre-trained** weights of the `SoftmaxRegression` model here: [softmax_regression_mia.pt](https://www.dropbox.com/s/t9wglqyj5zr74fq/softmax_mia.pt?dl=1) and save it into the local `checkpoints` folder\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34de5f7f", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path \n", + "\n", + "CHECKPOINT_FOLDER = Path(\"./checkpoints/\")\n", + "CHECKPOINT_FOLDER.mkdir(exist_ok=True)\n", + "\n", + "def load_weights(model, model_filename: str = None):\n", + " if model_filename is None or not model_filename:\n", + " model_filename = f\"{model.__class__.__name__.lower()}.pt\"\n", + " w_file = CHECKPOINT_FOLDER / model_filename\n", + " try:\n", + " weights = th.load(open(w_file, \"rb\"))\n", + " except FileNotFoundError: \n", + " print(f\"Model Weights file {w_file} does not exist! Please check.\")\n", + " return None\n", + " return weights\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d37c65ad", + "metadata": {}, + "outputs": [], + "source": [ + "softmax_reg = SoftmaxRegression()\n", + "weights = load_weights(softmax_reg, model_filename=\"softmax_mia.pt\")\n", + "if weights is not None:\n", + " softmax_reg.load_state_dict(weights)\n", + " \n", + "softmax_reg" + ] + }, + { + "cell_type": "markdown", + "id": "ba0018ae", + "metadata": {}, + "source": [ + "## MIA Reconstruction Strategy\n", + "\n", + "\n", + "\"MIA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81e83c5b", + "metadata": {}, + "outputs": [], + "source": [ + "def process(im_flatten):\n", + " max_v = th.max(im_flatten)\n", + " min_v = th.min(im_flatten)\n", + " return (im_flatten-min_v) / (max_v - min_v)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e52a0ac1", + "metadata": {}, + "outputs": [], + "source": [ + "def mi_face(model, target_label):\n", + " aim_tensor = th.zeros(1, 112*92)\n", + " aim_tensor.requires_grad = True\n", + " \n", + " lossn_1 = 10\n", + " b = 0\n", + " g = 0\n", + " \n", + " out = model(aim_tensor.detach())\n", + " _, pred = th.max(out, 1)\n", + " print(pred)\n", + " print(f'original input image {target_label}')\n", + " plt.imshow(np.transpose(aim_tensor.detach().reshape(1, 112, 92).numpy(), (1, 2, 0)), cmap=\"Greys\")\n", + " plt.show()\n", + " print(f'original input image predict label {target_label} - predict label: {pred.item()}')\n", + " \n", + " criterion = th.nn.NLLLoss()\n", + " \n", + " for i in range(α):\n", + " out = model(aim_tensor)\n", + " if aim_tensor.grad is not None:\n", + " aim_tensor.grad.zero_()\n", + " out = out.reshape(1, 40)\n", + " target_class = th.tensor([target_label])\n", + " loss = criterion(out, target_class)\n", + " loss.backward()\n", + " aim_grad = aim_tensor.grad\n", + " \n", + " # SGD Step\n", + " # see https://pytorch.org/docs/stable/generated/torch.optim.SGD.html#torch.optim.SGD\n", + " aim_tensor = aim_tensor - (λ * aim_grad)\n", + " aim_tensor = process(aim_tensor)\n", + " aim_tensor = th.clamp(aim_tensor.detach(), 0, 1)\n", + " aim_tensor.requires_grad = True\n", + " if loss >= lossn_1:\n", + " b += 1\n", + " if b > β:\n", + " break\n", + " else:\n", + " b = 0\n", + " lossn_1 = loss\n", + " if loss < γ:\n", + " break\n", + " \n", + " print(f\"Attack completed at {i} iterations\")\n", + " out = model(aim_tensor.detach())\n", + " _, pred = th.max(out, 1)\n", + " print(pred)\n", + " print(f'inverted image {target_label}')\n", + " plt.imshow(np.transpose(aim_tensor.detach().reshape(1, 112, 92).numpy() * 255, (1, 2, 0)), cmap=\"Greys\")\n", + " plt.show()\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44013f2f", + "metadata": {}, + "outputs": [], + "source": [ + "# Let's try to reconstruct the data for the first 10 classes (i.e. faces)\n", + "for cl in range(10):\n", + " mi_face(softmax_reg, cl)" + ] + }, + { + "cell_type": "markdown", + "id": "2f14d689", + "metadata": {}, + "source": [ + "### Exercise: \n", + "\n", + "Write the code to try the **model inversion reconstruction** using the `MLP` model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ad83641", + "metadata": {}, + "outputs": [], + "source": [ + "from models import MLP" + ] + }, + { + "cell_type": "markdown", + "id": "a3df4a1b", + "metadata": {}, + "source": [ + "⚠️ Grab the **pre-trained** weights of the `SoftmaxRegression` model here: [mlp_mia.pt](https://www.dropbox.com/s/8ul2lj2eqcykfxm/mlp_mia.pt?dl=1) and save it into the local `checkpoints` folder" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "58bab294", + "metadata": {}, + "outputs": [], + "source": [ + "mlp = MLP()\n", + "weights = load_weights(mlp, model_filename=\"mlp_mia.pt\")\n", + "if weights is not None:\n", + " mlp.load_state_dict(weights)\n", + "\n", + "mlp" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76662b42", + "metadata": {}, + "outputs": [], + "source": [ + "# Reconstruction Attack code HERE\n", + "for cl in range(10):\n", + " mi_face(mlp, cl)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/2-ml-models-attacks/4-MIA-Training-OPACUS.ipynb b/2-ml-models-attacks/4-MIA-Training-OPACUS.ipynb deleted file mode 100644 index 948b246..0000000 --- a/2-ml-models-attacks/4-MIA-Training-OPACUS.ipynb +++ /dev/null @@ -1,3503 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "0b9e9dde-7628-4d45-a408-afd93dd841ce", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "
\n", - " The notebook is using\n", - " \n", - " no$\\TeX$book Jupyter Theme (release 2.0.1).\n", - "\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Optional: setup NoTexBook theme\n", - "%load_ext notexbook\n", - "\n", - "%texify" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "439bc4c7-a72f-4a6c-81b0-0a54d062a676", - "metadata": {}, - "outputs": [], - "source": [ - "# UNCOMMENT THIS ONLY if running on Anaconda Notebooks and if needed\n", - "# Note: Same modules as in MIA Training notebooks!\n", - "\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/dataset.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/models.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/train.py" - ] - }, - { - "cell_type": "markdown", - "id": "dcd69b34", - "metadata": {}, - "source": [ - "# Model Inversion Attack - Model Training" - ] - }, - { - "cell_type": "markdown", - "id": "885f544c", - "metadata": {}, - "source": [ - "In this notebook we will repeat the same operations done in preparation for the **Model Inversion Attack** (in section 1) \n", - "\n", - "The very **big** difference this time though is that we will be using **Opacus** to train our ML model.\n", - "\n", - "$\\rightarrow$ ‼️ The very **remarkable** thing to notice is **how little** the implementation changes wrt. to the previous notebook\n", - "(in fact, we will be using the **same** `train` function defined previously)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "eee64647", - "metadata": {}, - "outputs": [], - "source": [ - "import torch as th\n", - "import numpy as np\n", - "\n", - "from matplotlib import pyplot as plt\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ff722fd0", - "metadata": {}, - "outputs": [], - "source": [ - "import warnings\n", - "warnings.simplefilter(\"ignore\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9086c266", - "metadata": {}, - "outputs": [], - "source": [ - "from dataset import ORLFaces\n", - "from torchvision.transforms import ToTensor, Grayscale, Compose\n", - "from torch.utils.data import DataLoader" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bbc48ffb", - "metadata": {}, - "outputs": [], - "source": [ - "SEED = 123456\n", - "\n", - "np.random.seed(SEED)\n", - "th.manual_seed(SEED)\n", - "if th.cuda.is_available():\n", - " th.cuda.manual_seed_all(SEED)\n", - " th.backends.cudnn.deterministic = True" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "93241bc5", - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", - "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", - "from six.moves import urllib\n", - "\n", - "opener = urllib.request.build_opener()\n", - "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", - "urllib.request.install_opener(opener)\n", - "\n", - "from pathlib import Path\n", - "import os\n", - "\n", - "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "c16625ec", - "metadata": {}, - "outputs": [], - "source": [ - "imgs_trasform = Compose([Grayscale(num_output_channels=1), ToTensor()])\n", - "\n", - "orl_faces_train = ORLFaces(\n", - " root=DATA_FOLDER, download=True, split=\"train\", transform=imgs_trasform\n", - ")\n", - "orl_faces_test = ORLFaces(\n", - " root=DATA_FOLDER, download=True, split=\"test\", transform=imgs_trasform\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b9ae6a51", - "metadata": {}, - "outputs": [], - "source": [ - "BATCH_SIZE = 32\n", - "\n", - "train_loader = DataLoader(\n", - " orl_faces_train, batch_size=BATCH_SIZE, shuffle=True, drop_last=False\n", - ")\n", - "test_loader = DataLoader(\n", - " orl_faces_test, batch_size=BATCH_SIZE, shuffle=False, drop_last=False\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "425c305c", - "metadata": {}, - "source": [ - "Show some of the training images, for fun" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "61e794b9", - "metadata": {}, - "outputs": [], - "source": [ - "from torchvision.utils import make_grid\n", - "\n", - "\n", - "def imshow(img):\n", - " npimg = img.numpy()\n", - " plt.figure(figsize=(10, 12))\n", - " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "6008bf8c", - "metadata": {}, - "outputs": [], - "source": [ - "# get some random training images\n", - "images, labels = next(iter(train_loader))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8e03a7f6", - "metadata": {}, - "outputs": [], - "source": [ - "# show images\n", - "imshow(make_grid(images))\n", - "# print labels\n", - "print(\" \".join(f\"{labels[j]}\" for j in range(BATCH_SIZE)))" - ] - }, - { - "cell_type": "markdown", - "id": "cdc04e1d", - "metadata": {}, - "source": [ - "## Privacy Parameters and Opacus" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e0d1c795", - "metadata": {}, - "outputs": [], - "source": [ - "from models import SoftmaxRegression, MLP" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "62df081d", - "metadata": {}, - "outputs": [], - "source": [ - "softmax_reg = SoftmaxRegression()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "b5030c0e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from opacus.validators import ModuleValidator\n", - "\n", - "errors = ModuleValidator.validate(softmax_reg, strict=False)\n", - "errors" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "dd545cdb", - "metadata": {}, - "outputs": [], - "source": [ - "λ = 0.1 # optimiser learning rate" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "67025880", - "metadata": {}, - "outputs": [], - "source": [ - "softmax_reg = SoftmaxRegression()\n", - "softmax_sgd = th.optim.SGD(softmax_reg.parameters(), lr=λ)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "9449cbff", - "metadata": {}, - "outputs": [], - "source": [ - "from opacus import PrivacyEngine" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "cb9ff406", - "metadata": {}, - "outputs": [], - "source": [ - "from train import train" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "74c6ecf0", - "metadata": {}, - "outputs": [], - "source": [ - "MAX_GRAD_NORM = 1.2\n", - "EPSILON = 50\n", - "DELTA = 1e-5\n", - "EPOCHS = 200 # we have increased by 100 the number of epochs of training" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "562a43d0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using sigma=0.953216552734375 and C=1.2\n" - ] - } - ], - "source": [ - "privacy_engine = PrivacyEngine(accountant=\"gdp\")\n", - "\n", - "softmax_reg, softmax_sgd, train_loader = privacy_engine.make_private_with_epsilon(\n", - " module=softmax_reg,\n", - " optimizer=softmax_sgd,\n", - " data_loader=train_loader,\n", - " epochs=EPOCHS,\n", - " target_epsilon=EPSILON,\n", - " target_delta=DELTA,\n", - " max_grad_norm=MAX_GRAD_NORM,\n", - ")\n", - "\n", - "print(f\"Using sigma={softmax_sgd.noise_multiplier} and C={MAX_GRAD_NORM}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "4f9c046a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using mps Device\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3768e531b37b4d838268231edf2a4a76", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Epochs: 0%| | 0/200 [00:00\n", - " /*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "*/\n", - "\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ======================================================\n", - " FONTS\n", - "\n", - " FONT WEIGHT MAP:\n", - " ----------------\n", - " 100: Ultra Light\n", - " 200: Thin\n", - " 300: Light\n", - " 400: Regular (normal)\n", - " 500: Medium\n", - " 600: Semi-bold\n", - " 700: Bold\n", - " 800: Heavy\n", - " 900: Black\n", - "\n", - " Font faces:\n", - " - ====================================|=======================\n", - " - Scope | Font Family Name\n", - " - ====================================| ======================\n", - " - Markdown Display (Computer Modern) (CMU Serif)\n", - " - Markdown Display monospace (CMU Typewriter Text)\n", - " - Markdown Edit monospace (Hack)\n", - " - Source Code monospace (Fira Code)\n", - " - ====================================| =======================\n", - "\n", - " ====================================================== */\n", - "\n", - "/* Roboto Slab */\n", - "@import url(\"https://fonts.googleapis.com/css2?family=Roboto+Slab:wght@100;200;300;400;500;600;700;800;900&display=swap\");\n", - "/*md-display-computer-modern --> CMU Serif*/\n", - "@import url(\"https://fonts.cdnfonts.com/css/cmu-serif?styles=30038,30039,30037,30036\");\n", - "/*md-display-monospace --> CMU Typewriter Text*/\n", - "@import url(\"https://fonts.cdnfonts.com/css/cmu-typewriter-text?styles=24833,24829,24830,24831,24832,24834\");\n", - "/*code-monospace --> Fira Code*/\n", - "@import url(\"https://fonts.googleapis.com/css2?family=Fira+Code:wght@300;400;500&display=swap\");\n", - "/*md-edit-monospace --> Hack*/\n", - "@import url(\"https://fonts.cdnfonts.com/css/hack?styles=20708,20707,20705,20706\");\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - "======================================================\n", - "\n", - "\n", - " ---------------------------------\n", - " Code Mirror - Code Cell Highlight\n", - " ---------------------------------\n", - "\n", - " Define the Style for Code **and** Markdown editors (Themes)\n", - " Theme files are all located in the \"themes\" folder, and the\n", - " different styles for the Code and Markdown editors are\n", - " distinguished by a common prefix in the file names:\n", - "\n", - " --> Code editors Themes: \"themes/code_*\"\n", - " --> Markdown Editor Themes: \"themes/md_*\"\n", - "\n", - " Styles can be imported as separate CSS modules.\n", - "\n", - " Current stylesheet (editor.css) defines the CSS rules\n", - " for notebook tags and classes. These rules are\n", - " all based to colors defined in external Theme files.\n", - "\n", - " This would ease the definition of other custom CSS Editor themes\n", - "*/\n", - "\n", - "/* Code Editor theme */\n", - "\n", - " /*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ======================================================\n", - "\n", - "The color palette is inspired by Light\n", - " Material Design theme\n", - "Repo: https://github.com/JonaDuran/Material-Light-Theme/\n", - "*/\n", - "\n", - ":root {\n", - " /* Color Palette */\n", - " --ml-white: #ffffff;\n", - " --ml-light-white: #FAFAFA;\n", - " --ml-black: #24292E;\n", - " --ml-dark-blue : #01579B11;\n", - " --ml-dark-blue-2: #01579B22;\n", - " --ml-blue: #1565C0;\n", - " --ml-green: #2E7D32;\n", - " --ml-yellow: #A8601A;\n", - " --ml-cyan: #00838f;\n", - " --ml-magenta: #9C00B0;\n", - " --ml-red: #C0392B;\n", - " --ml-grey: #9E9E9E;\n", - " --ml-light-blue: #78909c;\n", - "\n", - "\n", - " /* Editor Theme */\n", - " --code-background-color: var(--ml-light-white);\n", - " --gutter-background: var(--ml-light-white);\n", - " --selection-background-color: var(--ml-dark-blue-2);\n", - " --line-numbers: var(--ml-grey);\n", - " --cursor: var(--ml-black);\n", - " --bracket: var(--ml-black);\n", - " --matching-bracket: var(--ml-blue);\n", - " --code-text-color: var(--ml-black);\n", - " --keywords: var(--ml-magenta);\n", - " --types: var(--ml-magenta);\n", - " --variables: var(--code-text-color);\n", - " --variables2: var(--ml-green);\n", - " --def: var(--ml-blue);\n", - " --property: var(--ml-blue);\n", - " --meta: var(--ml-light-blue);\n", - " --builtin: var(--ml-blue);\n", - " --attribute: var(--ml-blue);\n", - " --strings: var(--ml-yellow);\n", - " --strings2: var(--ml-grey);\n", - " --comments: var(--ml-grey);\n", - " --operator: var(--ml-magenta);\n", - " --numbers: var(--ml-red);\n", - " /* Dataframe */\n", - " --dataframe: var(--code-text-color);\n", - " --df-bg: var(--ml-light-white);\n", - " --df-thead: var(--ml-blue);\n", - " --df-thead-border: var(--ml-black);\n", - " --df-tr-hover: var(--selection-background-color);\n", - " --df-border: var(--ml-white);\n", - " --df-border-right: var(--ml-grey);\n", - " --df-th-bg: var(--ml-white);\n", - " /*ANSI Colours*/\n", - " --ansi-red: var(--ml-red);\n", - " --ansi-green: var(--ml-green);\n", - " --ansi-green-intense: var(--ml-grey);\n", - " --ansi-cyan: var(--ml-cyan);\n", - " --ansi-blue: var(--ml-blue);\n", - "}\n", - "\n", - "\n", - "\n", - "/* Markdown Editor theme */\n", - "\n", - " /*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ======================================================\n", - "\n", - " Custom Theme for Markdown Editor\n", - " based on Material Clear Theme.\n", - "\n", - " */\n", - "\n", - ":root {\n", - " /* Color Palette */\n", - " --md-ml-red: #C0392B;\n", - " --md-ml-yellow: #A8601A;\n", - " --md-ml-black: #24292E;\n", - " --md-ml-grey: #9E9E9E;\n", - " --md-ml-blue: #1565C0;\n", - " --md-ml-dark-blue: #01579B;\n", - " --md-ml-light-blue: #78909c;\n", - "\n", - " /* Editor Theme */\n", - " --editor-text: var(--md-ml-black);\n", - " --header: var(--md-ml-dark-blue);\n", - " --quote: var(--md-ml-grey);\n", - " --link: var(--md-ml-blue);\n", - " --attribute: var(--md-ml-red);\n", - " --tag: var(--md-ml-yellow);\n", - " --string: var(--md-ml-yellow);\n", - " --delimiter: var(--md-ml-black);\n", - " --monospace: var(--md-ml-light-blue);\n", - "}\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "*/\n", - "\n", - "/*\n", - " =================\n", - " Code Editor Theme\n", - " =================\n", - "*/\n", - "div.output_error pre,\n", - "div.output_result pre,\n", - "div.output_stream pre {\n", - " color: var(--code-text-color) !important;\n", - "}\n", - "\n", - ".cm-s-ipython.CodeMirror,\n", - ".cm-s-jupyter.CodeMirror {\n", - " background: var(--code-background-color);\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - ".cm-s-ipython div.CodeMirror-selected,\n", - ".cm-s-jupyter div.CodeMirror-selected {\n", - " cursor: pointer;\n", - " background: var(--selection-background-color);\n", - "}\n", - "\n", - ".cm-s-ipython .CodeMirror-gutters,\n", - ".cm-s-jupyter .CodeMirror-gutters {\n", - " background: var(--gutter-background);\n", - " border-right: 0;\n", - "}\n", - "\n", - ".cm-s-ipython .CodeMirror-linenumber,\n", - ".cm-s-jupyter .CodeMirror-linenumber {\n", - " color: var(--line-numbers);\n", - "}\n", - "\n", - ".cm-s-ipython .CodeMirror-cursor,\n", - ".cm-s-jupyter .CodeMirror-cursor {\n", - " border-left: 1px solid var(--cursor) !important;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-bracket,\n", - ".cm-s-jupyter span.cm-bracket {\n", - " /*color: #828282;*/\n", - " color: var(--bracket);\n", - "}\n", - "\n", - "span.CodeMirror-matchingbracket {\n", - " text-decoration: underline !important;\n", - " text-decoration-color: var(--matching-bracket) !important;\n", - " color: var(--matching-bracket) !important;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-keyword,\n", - ".cm-s-jupyter span.cm-keyword {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-variable,\n", - ".cm-s-jupyter span.cm-variable {\n", - " color: var(--variables);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-variable-2,\n", - ".cm-s-jupyter span.cm-variable-2 {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-def,\n", - ".cm-s-jupyter span.cm-def {\n", - " color: var(--def);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-property,\n", - ".cm-s-jupyter span.cm-property {\n", - " color: var(--property);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-meta,\n", - ".cm-s-jupyter span.cm-meta {\n", - " color: var(--meta);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-attribute,\n", - ".cm-s-jupyter span.cm-attribute {\n", - " color: var(--attribute);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-builtin,\n", - ".cm-s-jupyter span.cm-builtin {\n", - " color: var(--builtin)\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-string,\n", - ".cm-s-jupyter span.cm-string {\n", - " color: var(--strings);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-string-2,\n", - ".cm-s-jupyter span.cm-string-2 {\n", - " color: var(--strings2);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-comment,\n", - ".cm-s-jupyter span.cm-comment {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-operator,\n", - ".cm-s-jupyter span.cm-operator {\n", - " color: var(--operator);\n", - " font-weight: 400;\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-number,\n", - ".cm-s-jupyter span.cm-number {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - ".cm-s-ipython span.cm-type,\n", - ".cm-s-jupyter span.cm-type {\n", - " color: var(--types);\n", - "}\n", - "\n", - "/*\n", - "==============================\n", - "Markdown MathJax Customisation\n", - "==============================\n", - "*/\n", - "\n", - "/*This customisation only applies to Math Display showing the font bigger than normal*/\n", - ".MathJax_Display {\n", - " font-size: 2rem;\n", - "}\n", - "\n", - ".MathJax_Display .mjx-char {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - "}\n", - "\n", - ".MathJax_Display, .MathJax span {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "a .MathJax span {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "a:hover .MathJax span {\n", - " text-decoration: underline;\n", - " color: var(--link-color);\n", - "}\n", - "\n", - ".MathJax span[style*=\"STIXMathJax_Normal\"],\n", - ".MathJax span[style*=\"STIXMathJax_Normal-italic\"],\n", - ".MathJax span[style*=\"STIXMathJax_Main\"],\n", - ".MathJax span[style*=\"STIXMathJax_Variants\"] {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - "}\n", - "\n", - "\n", - "/*\n", - " Pygments CSS (replacement) for HTML export\n", - " ===========================================\n", - "\n", - " Original Pygments CSS rewrite thanks to @rubik\n", - " https://github.com/jupyter/nbconvert/issues/447#issuecomment-270766965\n", - "*/\n", - "\n", - ".highlight .hll, div.highlight > pre {\n", - " background-color: var(--code-background-color);\n", - " color: var(--code-text-color);\n", - " font-family: var(--txbk-code-font-family);\n", - " font-size: var(--txbk-code-font-size);\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - "/* Comment */\n", - ".highlight .c {\n", - " color: var(--comments);\n", - "}\n", - "\n", - "/* Error */\n", - ".highlight .err {\n", - " color: #960050;\n", - " background-color: #1e0010;\n", - "}\n", - "\n", - "/* Keyword */\n", - ".highlight .k {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Literal */\n", - ".highlight .l {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/* Name */\n", - ".highlight .n {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* HACK:\n", - "fix Interpreter mismatch pygments vs codemirror\n", - "mpl.rcParams <- rcParams will be highlighted as property (as in codemirror)\n", - "*/\n", - ".highlight .o + .n {\n", - " color: var(--property);\n", - "}\n", - "\n", - "/* Operator */\n", - ".highlight .o {\n", - " color: var(--code-text-color);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Punctuation */\n", - ".highlight .p {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* Comment.Multiline */\n", - ".highlight .cm {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Comment.Preproc */\n", - ".highlight .cp {\n", - " color: var(--meta);\n", - " font-style: normal;\n", - "}\n", - "\n", - ".highlight .cpf {\n", - " color: var(--meta);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Comment.Single */\n", - ".highlight .c1 {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Comment.Special */\n", - ".highlight .cs {\n", - " color: var(--comments);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* @ Generic.Deleted */\n", - ".highlight .gd {\n", - " color: var(--red);\n", - "}\n", - "\n", - "/* Generic.Emph */\n", - ".highlight .ge {\n", - " font-style: italic\n", - "}\n", - "\n", - "/* @ Generic.Inserted */\n", - ".highlight .gi {\n", - " color: #a6e22e\n", - "}\n", - "\n", - "/* Generic.Strong */\n", - ".highlight .gs {\n", - " font-weight: 500 !important;\n", - "}\n", - "\n", - "/* @ Generic.Subheading */\n", - ".highlight .gu {\n", - " color: #75715e\n", - "}\n", - "\n", - "/* */\n", - "\n", - "/* Keyword.Constant */\n", - ".highlight .kc {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Declaration */\n", - ".highlight .kd {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Namespace */\n", - ".highlight .kn {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Pseudo */\n", - ".highlight .kp {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Reserved */\n", - ".highlight .kr {\n", - " color: var(--keywords);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Keyword.Type */\n", - ".highlight .kt {\n", - " color: var(--types);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* Literal.Date */\n", - ".highlight .ld {\n", - " color: var(--numbers)\n", - "}\n", - "\n", - "/* Literal.Number */\n", - ".highlight .m {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/* Literal.String */\n", - ".highlight .s {\n", - " color: var(--string);\n", - "}\n", - "\n", - "/* Name.Attribute */\n", - ".highlight .na {\n", - " color: var(--property);\n", - "}\n", - "\n", - "/* Name.Builtin */\n", - ".highlight .nb {\n", - " color: var(--builtin);\n", - "}\n", - "\n", - "/* Name.Class */\n", - ".highlight .nc {\n", - " color: var(--def);\n", - " font-weight: normal !important;\n", - "}\n", - "\n", - "/* @ Name.Constant */\n", - ".highlight .no {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Decorator */\n", - ".highlight .nd {\n", - " color: var(--builtin);\n", - "}\n", - "\n", - "/* @ Name.Entity */\n", - ".highlight .ni {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Exception */\n", - ".highlight .ne {\n", - " color: var(--code-text-color);\n", - " font-weight: normal !important;\n", - "}\n", - "\n", - "/* Name.Function */\n", - ".highlight .nf, .highlight .fm {\n", - " color: var(--def);\n", - "}\n", - "\n", - "/* @ Name.Label */\n", - ".highlight .nl {\n", - " color: var(--comments);\n", - "}\n", - "\n", - "/* Name.Namespace */\n", - ".highlight .nn {\n", - " color: var(--code-text-color);\n", - " font-weight: normal !important;\n", - "}\n", - "\n", - "/* @ Name.Other */\n", - ".highlight .nx {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* @ Name.Property */\n", - ".highlight .py {\n", - " color: var(--property);\n", - "}\n", - "\n", - "/* @ Name.Tag */\n", - ".highlight .nt {\n", - " color: var(--tag);\n", - "}\n", - "\n", - "/* @ Name.Variable */\n", - ".highlight .nv {\n", - " color: var(--variables);\n", - "}\n", - "\n", - "/* Operator.Word */\n", - ".highlight .ow {\n", - " color: var(--operator);\n", - " font-weight: 400;\n", - "}\n", - "\n", - "/* @ Text.Whitespace */\n", - ".highlight .w {\n", - " color: var(--code-background-color);\n", - "\n", - "}\n", - "\n", - "/* Literal.Number.Bin */\n", - "/* Literal.Number.Float */\n", - "/* Literal.Number.Hex */\n", - "/* Literal.Number.Integer */\n", - "/* Literal.Number.Oct */\n", - ".highlight .mb,\n", - ".highlight .mf,\n", - ".highlight .mh,\n", - ".highlight .mi,\n", - ".highlight .mo {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/* Literal.String.Backtick */\n", - ".highlight .sb {\n", - " color: var(--strings2);\n", - "}\n", - "\n", - ".highlight .sc, /* Literal.String.Char */\n", - ".highlight .sd, /* Literal.String.Doc */\n", - ".highlight .s2, /* Literal.String.Double */\n", - ".highlight .sh, /* Literal.String.Heredoc */\n", - ".highlight .si, /* Literal.String.Interpol */\n", - ".highlight .sx, /* Literal.String.Other */\n", - ".highlight .sr, /* Literal.String.Regex */\n", - ".highlight .s1, /* Literal.String.Single */\n", - ".highlight .ss /* Literal.String.Symbol */\n", - "{\n", - " color: var(--strings);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Literal.String.Escape */\n", - ".highlight .se {\n", - " color: var(--red);\n", - "}\n", - "\n", - "/* Name.Builtin.Pseudo */\n", - ".highlight .bp {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Variable.Class */\n", - ".highlight .vc {\n", - " color: var(--variables);\n", - "}\n", - "\n", - "/* Name.Variable.Global */\n", - ".highlight .vg {\n", - " color: var(--variables2);\n", - "}\n", - "\n", - "/* Name.Variable.Instance */\n", - ".highlight .vi {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "/* Literal.Number.Integer.Long */\n", - ".highlight .il {\n", - " color: var(--numbers);\n", - "}\n", - "\n", - "/*\n", - " Dataframe Colors\n", - " ----------------\n", - " Adapt Dataframe table to comply with the theme\n", - "*/\n", - "\n", - "table.dataframe {\n", - " color: var(--dataframe) !important;\n", - "}\n", - "\n", - "table.dataframe tbody tr th {\n", - " background-color: var(--df-bg);\n", - "}\n", - "\n", - "table.dataframe tbody tr:hover {\n", - " background-color: var(--df-tr-hover);\n", - "}\n", - "\n", - "table.dataframe td, table.dataframe th {\n", - " border: 1px solid var(--df-border);\n", - "}\n", - "\n", - "table.dataframe > th:not(:empty) {\n", - " background-color: var(--df-th-bg);\n", - "}\n", - "\n", - "table.dataframe tr:nth-child(2) th:empty,\n", - "table.dataframe tr:nth-child(2) th:empty {\n", - " border-right: 1px dotted var(--df-border-right);\n", - "}\n", - "\n", - "table.dataframe thead tr th:not(:empty) {\n", - " color: var(--df-thead);\n", - " border-bottom: 1px solid var(--df-thead-border);\n", - "}\n", - "\n", - "/* =======================================\n", - " ANSI colors\n", - " (stdout / stderr color customisation)\n", - " =======================================\n", - "*/\n", - "\n", - "span.ansi-green-fg {\n", - " color: var(--ansi-green) !important;\n", - "}\n", - "\n", - "span.ansi-green-intense-fg{\n", - " color: var(--ansi-green-intense) !important;\n", - "}\n", - "\n", - "span.ansi-red-fg {\n", - " color: var(--ansi-red) !important;\n", - "}\n", - "\n", - "span.ansi-cyan-fg {\n", - " color: var(--ansi-cyan) !important;\n", - "}\n", - "\n", - "span.ansi-blue-fg {\n", - " color: var(--ansi-blue) !important;\n", - "}\n", - "\n", - "span.ansi-bold {\n", - " font-weight: 500 !important;\n", - "}\n", - "\n", - "/* ----------------------------------- */\n", - "\n", - "/*\n", - " ======================\n", - " Markdown Editor Theme\n", - " ======================\n", - "*/\n", - "\n", - "div.text_cell.unrendered pre {\n", - " color: var(--editor-text) !important;\n", - "}\n", - "\n", - "span.cm-header {\n", - " color: var(--header) !important;\n", - " font-weight: 500;\n", - "}\n", - "\n", - "span.cm-quote {\n", - " color: var(--quote) !important;\n", - "}\n", - "\n", - "span.cm-string.cm-url {\n", - " color: var(--link) !important;\n", - "}\n", - "\n", - "span.cm-string {\n", - " color: var(--strings) !important;\n", - "}\n", - "/* Sometimes useful in Mono code Highlighting*/\n", - "span.cm-string-2 {\n", - " color: var(--strings2) !important;\n", - "}\n", - "\n", - "span.cm-link {\n", - " color: var(--link) !important;\n", - "}\n", - "\n", - "span.cm-attribute {\n", - " color: var(--attribute) !important;\n", - "}\n", - "\n", - "span.cm-tag {\n", - " color: var(--tag) !important;\n", - "}\n", - "\n", - "span.cm-delimiter {\n", - " color: var(--delimiter) !important;\n", - "}\n", - "\n", - "span.cm-comment {\n", - " color: var(--comments) !important;\n", - "}\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "\n", - " ---------------------------------------\n", - " CODE CELL OUTPUT (DISPLAY MODE)\n", - "\n", - " Pandas DataFrame - as HTML Table\n", - " (includes also HTML tables)\n", - "\n", - "\n", - " Note: This stylesheet does NOT include\n", - " any color nor background color for tables,\n", - " as those are assumed to be part of the\n", - " Coding colourisation theme.\n", - "\n", - " ---------------------------------------\n", - "*/\n", - "table.dataframe {\n", - " border-collapse: collapse;\n", - " border: none;\n", - " margin-left: 20px !important;\n", - " font-size: var(--txbk-code-font-size) !important;\n", - "}\n", - "\n", - "table.dataframe thead {\n", - " padding-bottom: 10px;\n", - "}\n", - "\n", - "table.dataframe thead tr {\n", - " font-style: normal;\n", - " padding: 5px 10px;\n", - " border-bottom: 1px solid;\n", - " vertical-align: middle;\n", - " text-align: center;\n", - " empty-cells: hide;\n", - "}\n", - "\n", - "table.dataframe thead tr th,\n", - "table.dataframe thead tr:only-child th {\n", - " vertical-align: middle;\n", - " text-align: center;\n", - "}\n", - "\n", - "table.dataframe tbody {\n", - " padding-top: 5px;\n", - "}\n", - "\n", - "table.dataframe tbody tr {\n", - "}\n", - "\n", - "table.dataframe tbody tr th {\n", - " text-align: left !important;\n", - " font-style: italic;\n", - " font-weight: normal;\n", - " margin-right: 5px;\n", - "}\n", - "\n", - "table.dataframe tbody tr td {\n", - " padding-left: 1.0rem;\n", - " padding-right: 1.0rem;\n", - "}\n", - "\n", - "table.dataframe tr {\n", - " border: none;\n", - "}\n", - "\n", - "table.dataframe td,\n", - "table.dataframe th {\n", - " padding-left: 0.25em;\n", - " padding-right: 0.25em;\n", - "}\n", - "\n", - "table.dataframe > th:not(:empty) {\n", - " text-align: left;\n", - " padding: 0 10px;\n", - " font-style: italic\n", - "}\n", - "\n", - "table.dataframe tr:nth-child(2) th:empty,\n", - "table.dataframe tr:nth-child(2) th:empty {\n", - " border-left: none;\n", - "}\n", - "\n", - "table.dataframe td {\n", - " padding: 0.375em 1em;\n", - "}\n", - "\n", - "table.dataframe thead {\n", - "\tpadding: 10px 0;\n", - "\tfont-weight: bold;\n", - "}\n", - "\n", - "table.dataframe thead tr th:not(:empty) {\n", - " text-align: left;\n", - " font-style: normal;\n", - " padding: 5px 10px;\n", - "}\n", - "\n", - "/* Hacking Font-weight bold capped at 500 */\n", - ".rendered_html th {\n", - " font-weight: 500 !important;\n", - "}\n", - ":root {\n", - " /* Jupyter Lab Integration (Light Theme) */\n", - "\n", - " --jp-ui-font-family: var(--txbk-ui-font-family);\n", - " --jp-ui-font-color1: var(--txbk-ui-color);\n", - " --jp-ui-font-size1: var(--txbk-ui-font-size);\n", - "\n", - " --jp-content-font-color1: var(--txbk-content-mono-color);\n", - " --jp-content-font-family: var(--txbk-content-font-family);\n", - " --jp-content-line-height: var(--txbk-content-line-height);\n", - " --jp-content-link-color: var(--link-color);\n", - " --jp-content-font-size: var(--txbk-content-font-size);\n", - " --jp-content-heading-font-weight: bold;\n", - " --jp-content-heading-line-height: 1;\n", - "\n", - " --jp-layout-color3: #efefef;\n", - " --jp-notebook-multiselected-color: var(--txbk-multiselect-bgcolor);\n", - "\n", - " --jp-code-font-size: var(--txbk-code-font-size);\n", - " --jp-code-line-height: var(--txbk-ui-mono-line-height);\n", - " --jp-code-padding: 5px;\n", - " --jp-code-font-family-default: var(--txbk-code-font-family);\n", - " --jp-code-font-family: var(--jp-code-font-family-default);\n", - " --jp-code-presentation-font-size: var(--txbk-ui-mono-font-size);\n", - "\n", - " --jp-cell-prompt-font-family: var(--txbk-code-font-family);\n", - " --jp-cell-prompt-width: 80px;\n", - "\n", - " --jp-cell-editor-border-color: transparent;\n", - "\n", - " --jp-layout-color0: var(--code-background-color);\n", - " --jp-cell-prompt-not-active-font-color: #aba9a9;\n", - "\n", - " --jp-cell-editor-background: var(--code-background-color);\n", - " --jp-cell-editor-active-background: var(--code-background-color);\n", - " --jp-cell-editor-active-border-color: var(--txbk-cell-edit-border-color);\n", - "\n", - "}\n", - "\n", - "/* ================\n", - " Jupyter Lab UI\n", - " ================\n", - "*/\n", - "\n", - ".jp-DirListing-item.jp-mod-running .jp-DirListing-itemIcon:before {\n", - " color: var(--btn-danger);\n", - "}\n", - "\n", - ".jp-DirListing-item.jp-mod-selected {\n", - " background-color: var(--texbook-blue);\n", - " color: white;\n", - "}\n", - "\n", - "button.jp-RunningSessions-shutdownAll.jp-mod-styled {\n", - " color: var(--btn-warning)\n", - "}\n", - "\n", - "button.jp-RunningSessions-shutdownAll.jp-mod-styled {\n", - " color: var(--btn-warning);\n", - "}\n", - "\n", - ".jp-icon-warn0[fill] {\n", - " fill: var(--texbook-turquoise);\n", - "}\n", - "\n", - "#jp-MainLogo .jp-icon-warn0[fill] {\n", - " /* Set default not to override logo colour */\n", - " fill: var(--jp-warn-color0);\n", - "}\n", - "\n", - "/* Change Colour only of Icons on the left-hand side toolbar */\n", - ".jp-SideBar.lm-TabBar.jp-mod-left .jp-icon3[fill] {\n", - " fill: var(--texbook-yellow);\n", - "}\n", - "\n", - ".jp-SideBar.lm-TabBar.jp-mod-left.lm-TabBar-tab.lm-mod-current .jp-icon3[fill] {\n", - " fill: var(--texbook-orangex);\n", - "}\n", - "\n", - "/*Kernel*/\n", - "div.f14jk5uf[title=\"Kernel Busy\"] .jp-icon3[fill] {\n", - " fill: var(--kernel-busy);\n", - "}\n", - "\n", - "div.f14jk5uf[title=\"Kernel Idle\"] .jp-icon3[fill] {\n", - " fill: var(--kernel-idle);\n", - "}\n", - "\n", - "div.f14jk5uf[title=\"Kernel Unknown\"] .jp-icon3[fill],\n", - "div.f14jk5uf[title=\"Kernel Restarting\"] .jp-icon3[fill] {\n", - " fill: var(--kernel-disconnected);\n", - "}\n", - "\n", - "\n", - "/* body class*/\n", - "\n", - "body[data-jp-theme-light=\"true\"]:not(.jp-Notebook) {\n", - " font-family: var(--jp-ui-font-family);\n", - " background: var(--jp-layout-color3) !important;\n", - " margin: 0;\n", - " padding: 0;\n", - " overflow: hidden;\n", - "}\n", - "\n", - ".jp-Notebook {\n", - " background-color: var(--background-color) !important;\n", - " font-weight: 300;\n", - " color: var(--txbk-ui-color);\n", - " font-size: var(--txbk-ui-font-size);\n", - "}\n", - "\n", - "\n", - "/* -------------------------------------------------\n", - " HTML Cells output generics\n", - " (overriding default JupyterLab theme settings)\n", - " -------------------------------------------------\n", - "*/\n", - "\n", - ".jp-RenderedHTMLCommon :not(pre) > code {\n", - " background-color: transparent !important;\n", - " padding: 0 0 !important;\n", - "}\n", - "\n", - ".jp-RenderedHTMLCommon pre, .jp-RenderedHTMLCommon code {\n", - " background-color: transparent !important;\n", - "}\n", - "\n", - ".jp-RenderedHTMLCommon p {\n", - " margin-bottom: 0;\n", - "}\n", - "\n", - ".jp-RenderedHTMLCommon * + p {\n", - " margin-top: 1em;\n", - "}\n", - "\n", - "\n", - "/* ======================================\n", - " MARKDOWN CELLS DISPLAY MODE\n", - " (text_cell_render in Notebook HTML)\n", - " ======================================\n", - "*/\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " color: var(--txbk-content-color) !important;\n", - " font-kerning: auto;\n", - " text-align: justify !important;\n", - " display: block;\n", - " word-break: normal !important;\n", - " word-wrap: break-word !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon a {\n", - " color: var(--link-color) !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h1,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h2,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h3,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h4,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h5,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h6 {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-style: normal !important;\n", - "}\n", - "\n", - "/* Font-sizes for Headers\n", - " ----------------------*/\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h1 {\n", - " font-size: 2.2em !important;\n", - " text-align: center !important;\n", - " padding-top: 3rem;\n", - " padding-bottom: 3rem;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h2 {\n", - " font-size: 1.9em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h3 {\n", - " font-size: 1.7em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h4 {\n", - " font-size: 1.5em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h5 {\n", - " font-size: 1.3em !important;\n", - " border-bottom: 1px solid rgb(204, 204, 204);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon h6 {\n", - " font-size: 1.1em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon code {\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "\n", - "/* Monospace Code - no code syntax highlight*/\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre {\n", - " /* hack: using code background colour here to allow for compatibility */\n", - " background-color: var(--code-background-color) !important;\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p {\n", - " line-height: var(--txbk-content-line-height);\n", - " text-align: justify !important;\n", - "}\n", - "\n", - "/* Monospace inline rendered markdown */\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p code {\n", - " /*Re-defining variables for Mono using Code Editor's settings*/\n", - " font-size: var(--txbk-content-mono-font-size);\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p strong code {\n", - " font-weight: bold !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p em code {\n", - " font-style: italic !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon pre code {\n", - " padding: 1rem 1.5rem;\n", - " display: block;\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " word-wrap: break-word;\n", - " word-break: normal;\n", - " /* Important Override rules */\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon blockquote {\n", - " --txbk-ui-color: #6f6f6f;\n", - " margin: .2rem .2rem;\n", - " padding: .3rem .5rem;\n", - " border-left: .3rem solid #a7a7a7;\n", - " background-color: var(--txbk-content-mono-bgcolor);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon blockquote:not(:first-child) {\n", - " margin: 2rem .2rem;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon blockquote p {\n", - " padding: .2rem 1.5rem;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table {\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " border-collapse: collapse;\n", - " border-spacing: 0;\n", - " overflow: auto;\n", - " break-inside: auto;\n", - " margin-top: 25px;\n", - " margin-bottom: 15px;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table thead {\n", - " display: table-header-group;\n", - " vertical-align: middle;\n", - " border-bottom: none;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table thead tr,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table thead tr td,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tbody tr,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tbody tr th,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tbody tr td {\n", - " break-inside: avoid;\n", - " break-after: auto;\n", - " vertical-align: middle;\n", - " padding: 5px 5px;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon table tr th {\n", - " border-bottom-width: 0;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol {\n", - " position: relative;\n", - " display: block;\n", - " margin-bottom: 0 !important;\n", - " line-height: var(--txbk-content-line-height);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul {\n", - " list-style-type: disc;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul li,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol li {\n", - " padding: .25em;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul ul {\n", - " list-style-type: circle !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul li > ul li a code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul li > ol li a code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol li > ul li a code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ol li > ol li a code {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon ul ul ul {\n", - " list-style-type: square !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img:only-child,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img:only-child {\n", - " display: block;\n", - " margin: auto;\n", - " max-width: 40%;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img {\n", - " max-width: 40%;\n", - "}\n", - "\n", - "/* Img MaxW classes */\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw10,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw10 {\n", - " max-width: 10% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw15,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw15 {\n", - " max-width: 15% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw20,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw20 {\n", - " max-width: 20% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw25,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw25 {\n", - " max-width: 25% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw30,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw30 {\n", - " max-width: 30% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw35,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw35 {\n", - " max-width: 35% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw40,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw40 {\n", - " max-width: 40% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw45,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw45 {\n", - " max-width: 45% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw50,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw50 {\n", - " max-width: 50% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw55,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw55 {\n", - " max-width: 55% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw60,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw60 {\n", - " max-width: 60% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw65,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw65 {\n", - " max-width: 65% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw70,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw70 {\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw75,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw75 {\n", - " max-width: 75% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw80,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw80 {\n", - " max-width: 80% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw85,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw85 {\n", - " max-width: 85% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw90,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw90 {\n", - " max-width: 90% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw95,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw95 {\n", - " max-width: 95% !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon img.maxw100,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p > img.maxw100 {\n", - " max-width: 100% !important;\n", - "}\n", - "\n", - "/* FIX Forcing monospace code to adhere with footnotes rules!*/\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p [id^='fn'] > code,\n", - ".jp-Notebook .jp-MarkdownCell .jp-RenderedHTMLCommon p [class^='fn'] > code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "/* Code Cell Render (HTML output) */\n", - ".jp-CodeCell .jp-RenderedHTMLCommon {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-RenderedHTMLCommon p {\n", - " font-family: var(--txbk-code-font-family);\n", - " font-size: 1.4em;\n", - " font-weight: normal;\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-RenderedHTMLCommon .nomono {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-size: 1em;\n", - " margin-top: 0;\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell:not(.jp-mod-dropTarget) {\n", - " background: transparent;\n", - " border: none;\n", - "}\n", - "\n", - "/* Code Cell Editor */\n", - "\n", - ".jp-InputArea-editor {\n", - " background-color: var(--jp-cell-editor-active-background);\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell .jp-InputArea-editor,\n", - ".jp-Notebook .jp-MarkdownCell .jp-MarkdownOutput {\n", - " /* Set default LEFT border as transparent - to avoid change in paddings when selected */\n", - " border-left: 0.2rem dotted var(--txbk-cell-border-color);\n", - " box-shadow: none;\n", - " border-right: none;\n", - " border-top: none;\n", - " border-bottom: none;\n", - " overflow: hidden;\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell .jp-Cell-inputWrapper {\n", - " /* Set default RIGHT border as transparent - to avoid change in paddings when selected */\n", - " border-right: 5px solid var(--txbk-cell-border-color);\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea-editor,\n", - ".jp-Notebook.jp-mod-commandMode .jp-MarkdownCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-MarkdownOutput {\n", - " /* Force border redefinition to override default Jupyter theme rules */\n", - " border-left: 0.2rem dotted var(--txbk-cell-selected-border-left-color);\n", - " box-shadow: none;\n", - " border-right: none;\n", - " border-top: none;\n", - " border-bottom: none;\n", - " overflow: hidden;\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-Cell-inputWrapper {\n", - " border-right-color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-editMode .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-Cell-inputWrapper {\n", - " border-right-color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - "/* Cell Multiple Selection */\n", - ".jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-selected:not(.jp-mod-active),\n", - ".jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-multiSelected {\n", - " border: 2px dashed var(--texbook-azure);\n", - " background: var(--txbk-multiselect-bgcolor);\n", - " margin-top: 10px;\n", - "}\n", - "\n", - "/*\n", - " Overlay with Shadow for Code Cell Selected !\n", - " ============================================\n", - "*/\n", - "/* Overlay limited to CodeCells */\n", - ".jp-Notebook .jp-CodeCell.jp-mod-selected {\n", - " border: none;\n", - " background: transparent;\n", - " box-shadow: 0 6px 18px #aaa;\n", - " z-index: 10;\n", - " top: -10px;\n", - " padding-top: 12px;\n", - " padding-bottom: 12px;\n", - " margin-top: 18px;\n", - " margin-bottom: 2px;\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell.jp-mod-active.jp-mod-selected:before {\n", - " position: absolute;\n", - " display: none;\n", - " top: -1px;\n", - " left: -1px;\n", - " width: 0;\n", - " height: calc(100% + 2px);\n", - " content: '';\n", - " background: none;\n", - "}\n", - "\n", - ".jp-Notebook .jp-Cell .jp-Collapser {\n", - " display: none !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-InputPrompt {\n", - " color: var(--texbook-light-grey) !important;\n", - " font-style: normal !important;\n", - " font-size: 1em;\n", - " opacity: 1 !important;\n", - " font-weight: normal;\n", - " min-width: 9.5ex;\n", - "}\n", - "\n", - ".jp-OutputPrompt {\n", - " color: transparent !important;\n", - " min-width: 9.5ex; /* Aligns with Input Prompt */\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .jp-InputPrompt bdi,\n", - ".jp-Notebook .jp-CodeCell .jp-OutputPrompt bdi {\n", - " line-height: 0;\n", - " font-size:0;\n", - " color: transparent;\n", - " left: -10000px;\n", - " content: \"\\21E2\";\n", - "}\n", - "\n", - "/*.jp-Notebook .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputPrompt:before {*/\n", - ".jp-Notebook .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea:before {\n", - " display: inline-block;\n", - " position: absolute;\n", - " content: \"\\279E\";\n", - " font-size: 1.75rem;\n", - " top: 4px;\n", - " width: 10px;\n", - " left: 0;\n", - " font-weight: bold !important;\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-commandMode .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea:before {\n", - " color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".jp-Notebook.jp-mod-editMode .jp-CodeCell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) .jp-InputArea:before {\n", - " color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - "/* =============\n", - " Code Editors\n", - " ============= */\n", - "\n", - ".jp-Notebook .jp-Cell .CodeMirror * {\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - ".jp-Notebook .jp-CodeCell .CodeMirror * {\n", - " font-family: var(--txbk-code-font-family) !important;\n", - " font-size: var(--txbk-code-font-size) !important;\n", - "}\n", - "\n", - ".jp-Notebook .jp-MarkdownCell .CodeMirror * {\n", - " font-family: var(--txbk-md-font-family) !important;\n", - " font-size: var(--txbk-md-font-size) !important;\n", - "}\n", - "\n", - "/* Cell Output rendering (.output_area in Notebook HTML) */\n", - "\n", - ".jp-OutputArea-output.jp-RenderedText pre,\n", - ".jp-OutputArea-output.jp-RenderedMarkdown p {\n", - " padding-bottom: 15px;\n", - " padding-top: 10px;\n", - "}\n", - "\n", - ".jp-OutputArea-output.jp-RenderedMarkdown p {\n", - " font-size: var(--txbk-content-font-size);\n", - "}\n", - "\n", - ".jp-OutputArea-output.jp-RenderedMarkdown pre code {\n", - " font-size: var(--txbk-content-mono-font-size);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - ".jp-OutputArea-output.jp-RenderedText pre {\n", - " --txbk-content-mono-font-family: var(--txbk-code-font-family);\n", - " font-size: var(--txbk-code-font-size);\n", - " font-weight: normal;\n", - " word-break: normal;\n", - " word-wrap: break-word;\n", - "}\n", - "\n", - "/* Standard Error */\n", - ".jp-RenderedText[data-mime-type='application/vnd.jupyter.stderr'] {\n", - " background: none !important;\n", - "}\n", - "/*\n", - "Author: Valerio Maggio < @leriomaggio >\n", - "Code: https://github.com/leriomaggio/notexbook-jupyter-theme\n", - "License: Apache License 2.0\n", - "*/\n", - "\n", - "/* HTML Export (Jupyter Light Theme)\n", - " ================================ */\n", - "\n", - "body.jp-Notebook .jp-CodeCell .jp-InputPrompt {\n", - " margin-top: 7px;\n", - " overflow: initial;\n", - "}\n", - "\n", - "body.jp-Notebook .CodeMirror-linenumber {\n", - " --txbk-ui-mono-font-size: 10px !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-RenderedHTMLCommon.jp-MarkdownOutput p > img:only-child,\n", - "body.jp-Notebook .jp-RenderedHTMLCommon.jp-MarkdownOutput img:only-child {\n", - " max-width: 30%;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-CodeCell .jp-InputPrompt {\n", - " font-size: var(--txbk-code-font-size);\n", - " padding-top: 4px;\n", - "}\n", - "\n", - "/* ==================================================\n", - " IMPORTANT NOTE:\n", - " ALL markdown rules cells needs adapting because of\n", - " a different structure in exported HTML\n", - " ===================================================\n", - "*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " color: var(--txbk-content-color) !important;\n", - " font-kerning: auto;\n", - " text-align: justify !important;\n", - " display: block;\n", - " word-break: normal !important;\n", - " word-wrap: break-word !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput a {\n", - " color: var(--link-color) !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h1,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h2,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h3,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h4,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h5,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h6 {\n", - " font-family: var(--txbk-content-font-family) !important;\n", - " font-style: normal !important;\n", - "}\n", - "\n", - "/* Font-sizes for Headers\n", - " ----------------------*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h1 {\n", - " font-size: 2.2em !important;\n", - " text-align: center !important;\n", - " padding-top: 3rem;\n", - " padding-bottom: 3rem;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h2 {\n", - " font-size: 1.9em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h3 {\n", - " font-size: 1.7em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h4 {\n", - " font-size: 1.5em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h5 {\n", - " font-size: 1.3em !important;\n", - " border-bottom: 1px solid rgb(204, 204, 204);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput h6 {\n", - " font-size: 1.1em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput code {\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "\n", - "/* Monospace Code - no code syntax highlight*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre {\n", - " /* hack: using code background colour here to allow for compatibility */\n", - " background-color: var(--code-background-color) !important;\n", - " font-family: var(--txbk-content-mono-font-family) !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p {\n", - " line-height: var(--txbk-content-line-height);\n", - " text-align: justify !important;\n", - "}\n", - "\n", - "/* Monospace inline rendered markdown */\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p code {\n", - "\n", - " /*Re-defining variables for Mono using Code Editor's settings*/\n", - " --txbk-content-mono-font-family: var(--txbk-code-font-family);\n", - " --txbk-content-mono-font-size: var(--txbk-code-font-size);\n", - "\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p strong code {\n", - " font-weight: bold !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p em code {\n", - " font-style: italic !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-CodeCell .jp-RenderedHTMLCommon p.nomono {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-size: 1em;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput pre code {\n", - " padding: 1rem 1.5rem;\n", - " display: block;\n", - " color: var(--txbk-content-mono-color);\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " word-wrap: break-word;\n", - " word-break: normal;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput blockquote {\n", - " --txbk-ui-color: #6f6f6f !important;\n", - "\n", - " margin: 2rem .2rem !important;\n", - " padding: .3rem .5rem !important;\n", - " border-left: .3rem solid #a7a7a7 !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput blockquote p {\n", - " padding: .2rem 1.5rem;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table {\n", - " margin-top: 25px;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table {\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " border-collapse: collapse;\n", - " border-spacing: 0;\n", - " width: 100%;\n", - " overflow: auto;\n", - " break-inside: auto;\n", - " text-align: left;\n", - " margin-top: 25px;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table thead {\n", - " display: table-header-group;\n", - " vertical-align: middle !important;\n", - " border-bottom: none !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table thead tr,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table thead tr td,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tbody tr,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tbody tr th,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tbody tr td {\n", - " break-inside: avoid;\n", - " break-after: auto;\n", - " text-align: left !important;\n", - " vertical-align: middle !important;\n", - " padding: 0 !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput table tr th {\n", - " border-bottom-width: 0;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol {\n", - " position: relative;\n", - " display: block;\n", - " margin-bottom: 0 !important;\n", - " line-height: var(--txbk-content-line-height);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul {\n", - " list-style-type: disc;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li {\n", - " /*white-space: pre-wrap;*/\n", - " padding: .8rem !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > code {\n", - " font-size: .9em !important\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li a code {\n", - " font-size: .9em !important\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ul {\n", - " list-style-type: circle !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ul,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ol,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol ul,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol ol {\n", - " padding-top: .5rem !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ul li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ol li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ul li,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ol li {\n", - " padding: .5rem !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ul li code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ol li code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ul li code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ol li code {\n", - " font-size: .9em !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ul li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul li > ol li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ul li a code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ol li > ol li a code {\n", - " font-size: .9em !important;\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput ul ul ul {\n", - " list-style-type: square !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img:only-child,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img:only-child {\n", - " display: block;\n", - " margin: auto;\n", - " max-width: 40%;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img {\n", - " max-width: 40%;\n", - "}\n", - "\n", - "/* Img MaxW classes */\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw10,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw10 {\n", - " max-width: 5% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw15,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw15 {\n", - " max-width: 5% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw20,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw20 {\n", - " max-width: 10% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw25,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw25 {\n", - " max-width: 15% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw30,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw30 {\n", - " max-width: 20% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw35,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw35 {\n", - " max-width: 25% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw40,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw40 {\n", - " max-width: 30% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw45,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw45 {\n", - " max-width: 35% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw50,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw50 {\n", - " max-width: 40% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw55,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw55 {\n", - " max-width: 45% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw60,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw60 {\n", - " max-width: 50% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw65,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw65 {\n", - " max-width: 55% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw70,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw70 {\n", - " max-width: 60% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw75,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw75 {\n", - " max-width: 65% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw80,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw80 {\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw85,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw85 {\n", - " max-width: 75% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw90,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw90 {\n", - " max-width: 80% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw95,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw95 {\n", - " max-width: 85% !important;\n", - "}\n", - "\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput img.maxw100,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p > img.maxw100 {\n", - " max-width: 90% !important;\n", - "}\n", - "\n", - "/* FIX Forcing monospace code to adhere with footnotes rules!*/\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p [id^='fn'] > code,\n", - "body.jp-Notebook .jp-Cell-inputWrapper .jp-RenderedHTMLCommon.jp-RenderedMarkdown.jp-MarkdownOutput p [class^='fn'] > code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "\n", - "/* ======================================================\n", - " GLOBALS (with vars integration)\n", - " ======================================================\n", - "*/\n", - "\n", - "\n", - ":root {\n", - " --template-txbk-content-font-size: 16px;\n", - " --template-txbk-content-line-height: 1.4;\n", - " --template-txbk-content-mono-font-family: \"CMU Typewriter Text\", \"Fira Code\", monospace;\n", - " --template-txbk-code-font-family: \"Fira Code\", \"Fira Code\", monospace;\n", - " --template-txbk-md-font-family: \"Hack\", \"Hack\", monospace;\n", - " --template-txbk-code-font-size: 14px;\n", - " --template-txbk-md-font-size: 14px;\n", - "}\n", - "\n", - "/* ======================================================\n", - " GLOBALS\n", - " ======================================================\n", - "*/\n", - "\n", - ":root {\n", - " /* Base colors */\n", - " --texbook-red: #d43133;\n", - " --texbook-pink: #D14187;\n", - " --texbook-turquoise: #009489;\n", - " --texbook-azure: #00afde;\n", - " --texbook-blue: #2875d9;\n", - " --texbook-light-grey: #828282;\n", - " --texbook-dark-grey: rgb(56, 56, 56);\n", - " --texbook-yellow: #f9ab00;\n", - " --texbook-orange: #e8710a;\n", - "\n", - " /* Font formatting */\n", - " --background-color: #ffffff;\n", - " --txbk-ui-font-family: \"Roboto Slab\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n", - " --txbk-ui-color: rgb(51, 51, 51);\n", - " --txbk-ui-font-size: 14px;\n", - " --txbk-ui-line-height: 1;\n", - "\n", - " --txbk-ui-header-font-family: \"Roboto Slab\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n", - " --txbk-ui-header-color: rgb(56, 56, 56);\n", - "\n", - " --txbk-ui-mono-color: #828282;\n", - " --txbk-ui-mono-font-size: 15px;\n", - " --txbk-ui-mono-line-height: 1.4;\n", - "\n", - " /* Cells */\n", - " --txbk-cell-selected-border-left-color: lightgrey;\n", - " --txbk-cell-border-color: var(--background-color);\n", - " --txbk-multiselect-bgcolor: var(--background-color);\n", - " --txbk-cell-display-border-color: #009489;\n", - " --txbk-cell-edit-border-color: #d43133;\n", - "\n", - " /* Content Formatting */\n", - " --txbk-content-font-family: \"CMU Serif\", \"Times New Roman\", serif;\n", - " --txbk-content-font-size: var(--template-txbk-content-font-size);\n", - " --txbk-content-color: rgb(51, 51, 51);\n", - " --txbk-content-line-height: var(--template-txbk-content-line-height);\n", - "\n", - " --txbk-content-mono-font-family: var(--template-txbk-content-mono-font-family);\n", - " --txbk-content-mono-font-size: var(--txbk-content-font-size);\n", - " --txbk-content-mono-color: var(--texbook-dark-grey);\n", - " --txbk-content-mono-bgcolor: var(--code-background-color);\n", - "\n", - " --txbk-code-font-family: var(--template-txbk-code-font-family);\n", - " --txbk-code-font-size: var(--template-txbk-code-font-size);\n", - " --txbk-md-font-family: var(--template-txbk-md-font-family);\n", - " --txbk-md-font-size: var(--template-txbk-md-font-size);\n", - " --txbk-code-line-height: 1.6;\n", - " --txbk-code-color: var(--code-text-color);\n", - " --txbk-code-bgcolor: var(--code-background-color);\n", - "\n", - " --link-color: var(--texbook-blue);\n", - " --del-color: var(--texbook-red);\n", - " --drop-cap-color: var(--texbook-red);;\n", - "\n", - " --kernel-name-color: var(--texbook-azure);\n", - " --kernel-idle: var(--texbook-turquoise);\n", - " --kernel-busy: var(--texbook-pink);\n", - " --kernel-disconnected: var(--texbook-red);\n", - " --btn-warning: var(--texbook-pink);\n", - " --btn-danger: var(--texbook-red);\n", - " --running-notebook: var(--texbook-turquoise);\n", - "}\n", - "\n", - "html {\n", - " font-size: 10px;\n", - "}\n", - "\n", - "body {\n", - "\n", - " background-color: var(--background-color) !important;\n", - " font-weight: 300;\n", - " font-family: var(--txbk-ui-font-family);\n", - " color: var(--txbk-ui-color);\n", - " overflow: inherit;\n", - " vertical-align: middle;\n", - " font-size: var(--txbk-ui-font-size);\n", - "}\n", - "\n", - "h1, h2, h3, h4, h5, h6, label > strong {\n", - " font-family: var(--txbk-ui-header-font-family);\n", - " color: var(--txbk-ui-header-color);\n", - "}\n", - "\n", - "h1 img, h2 img , h3 img, h4 img, h5 img, h6 img {\n", - " display: inline !important;\n", - "}\n", - "\n", - "h1 {\n", - " font-weight: bold;\n", - " font-style: normal;\n", - "}\n", - "\n", - "h2 {\n", - " font-weight: bold;\n", - " font-style: italic;\n", - "}\n", - "\n", - "h3 {\n", - " font-weight: 600;\n", - " font-style: normal;\n", - "}\n", - "\n", - "h4 {\n", - " font-weight: 500;\n", - " font-style: normal;\n", - "}\n", - "\n", - "h5, h6 {\n", - " font-weight: 500;\n", - " font-style: italic;\n", - "}\n", - "\n", - "code, kbd, pre, samp {\n", - " font-family: var(--txbk-code-font-family);\n", - " color: var(--txbk-ui-mono-color);\n", - " font-weight: 400;\n", - " font-size: var(--txbk-ui-mono-font-size);\n", - " line-height: var(--txbk-ui-mono-line-height);\n", - "}\n", - "\n", - "table > thead > tr > td.info,\n", - "table > tbody > tr > td.info,\n", - "table > tfoot > tr > td.info,\n", - "table > thead > tr > th.info,\n", - "table > tbody > tr > th.info,\n", - "table > tfoot > tr > th.info,\n", - "table > thead > tr.info > td,\n", - "table > tbody > tr.info > td,\n", - "table > tfoot > tr.info > td,\n", - "table > thead > tr.info > th,\n", - "table > tbody > tr.info > th,\n", - "table > tfoot > tr.info > th {\n", - " background-color: #d9edf7;\n", - "}\n", - "\n", - "del {\n", - " color: var(--del-color) !important;\n", - "}\n", - "\n", - "/* ======================================================\n", - " Intro/Home Page Server\n", - " ======================================================\n", - "*/\n", - "\n", - "#ipython-main-app p {\n", - " text-align: justify !important;\n", - "}\n", - "\n", - ".toolbar_info,\n", - ".list-container {\n", - " color: #828282;\n", - "}\n", - "\n", - ".list_placeholder {\n", - " font-family: \"Roboto Slab\", serif !important;\n", - " font-weight: 300;\n", - " font-style: normal;\n", - "}\n", - "\n", - "a.item_link, a:hover.item_link {\n", - " color: var(--link-color);\n", - " font-weight: 300;\n", - "}\n", - "\n", - ".item_buttons .kernel-name {\n", - " color: var(--kernel-name-color);\n", - " font-weight: 400;\n", - "}\n", - "\n", - ".btn-warning {\n", - " background-color: var(--btn-warning) !important;\n", - " border-color: var(--btn-warning) !important;\n", - "}\n", - "\n", - ".btn-warning:focus {\n", - " border-color: var(--btn-warning) !important;\n", - "}\n", - "\n", - ".btn-danger {\n", - " background-color: var(--btn-danger) !important;\n", - " border-color: var(--btn-danger) !important;\n", - "}\n", - "\n", - ".btn-danger:focus {\n", - " border-color: var(--btn-danger) !important;\n", - "}\n", - "\n", - ".running-indicator,\n", - ".running_notebook_icon:before {\n", - " color: var(--running-notebook);\n", - "}\n", - "\n", - "\n", - "\n", - "/* ======================================================\n", - " Notebook\n", - " ======================================================\n", - "*/\n", - "\n", - "/* Modal Dialog */\n", - "\n", - ".modal-header > h4 {\n", - " font-style: normal !important;\n", - " text-decoration: none !important;\n", - " font-family: var(--txbk-ui-font-family) !important;\n", - " margin: 0 !important;\n", - "}\n", - "\n", - ".notebook_app {\n", - " background-color: var(--background-color) !important;\n", - " font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif !important;\n", - " font-weight: normal;\n", - "}\n", - "\n", - "div#notebook_name {\n", - " font-family: var(--txbk-ui-font-family) !important;\n", - " font-weight: normal;\n", - " font-size: 24px;\n", - " padding: 1px 7px 1px 1px;\n", - "}\n", - "\n", - "div#site {\n", - "\toverflow: inherit;\n", - " top: 112px;\n", - " position: absolute;\n", - "}\n", - "\n", - "#header {\n", - " display: block;\n", - " position: fixed !important;\n", - " top: 0;\n", - " width: 100%;\n", - " max-width: 100%;\n", - " height: fit-content;\n", - " background-color: var(--background-color);\n", - "}\n", - "\n", - "#notebook-container {\n", - " /* Remove shadow so that it looks like a page of a PDF doc */\n", - " box-shadow: none !important;\n", - " -webkit-box-shadow: none !important;\n", - " padding: 0;\n", - "}\n", - "\n", - "div#notebook {\n", - " border-top: none;\n", - " font-size: 1rem;\n", - " padding: 0 !important;\n", - " padding-top: 30px !important;\n", - " font-family: var(--txbk-content-font-family) !important;\n", - "}\n", - "\n", - ".kernel_idle_icon:before {\n", - " color: var(--kernel-idle);\n", - "}\n", - "\n", - ".kernel_busy_icon:before {\n", - " color: var(--kernel-busy);\n", - "}\n", - "\n", - ".kernel_disconnected_icon:before {\n", - " color: var(--kernel-disconnected);\n", - "}\n", - "\n", - "#notification_area {\n", - " font-family: var(--txbk-ui-font-family);\n", - "}\n", - "\n", - "#notification_kernel {\n", - " color: #fff;\n", - " background-color: var(--kernel-idle);\n", - " border-color: var(--kernel-idle);\n", - "}\n", - "\n", - "#notification_kernel.warning {\n", - " color: #fff;\n", - " background-color: var(--kernel-disconnected);\n", - " border-color: var(--kernel-disconnected);\n", - "}\n", - "\n", - "#notification_trusted {\n", - " border-color: var(--kernel-disconnected);\n", - "}\n", - "\n", - "#notification_trusted[disabled=\"disabled\"] {\n", - " border-color: var(--kernel-idle);\n", - "}\n", - "\n", - "\n", - "#notification_notebook {\n", - " border-color: var(--kernel-idle);\n", - "}\n", - "\n", - "/* -----------------------------------\n", - " CELLS\n", - " -----------------------------------\n", - "*/\n", - "\n", - "div.cell {\n", - " right: 2px;\n", - " border: none;\n", - " margin-top: 5px;\n", - "}\n", - "\n", - "div.cell.selected {\n", - " /* Reset all - ready for customisation */\n", - " border-radius: 0;\n", - " background: none;\n", - "}\n", - "\n", - "div.cell .inner_cell {\n", - " border-right: 5px solid var(--txbk-cell-border-color);\n", - " border-left: 0.2rem dotted var(--txbk-cell-border-color);\n", - "}\n", - "\n", - "div.cell.selected:not(.jupyter-soft-selected) .inner_cell {\n", - " border-left-color: var(--txbk-cell-selected-border-left-color);\n", - "}\n", - "\n", - ".command_mode div.cell.selected:not(.jupyter-soft-selected) .inner_cell {\n", - " border-right-color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".edit_mode div.cell.selected:not(.jupyter-soft-selected) .inner_cell {\n", - " border-right-color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - "/* Multiple Selection */\n", - ".command_mode div.cell.jupyter-soft-selected {\n", - " border: 2px dashed var(--texbook-azure);\n", - " background: var(--txbk-multiselect-bgcolor);\n", - " margin-top: 10px;\n", - "}\n", - "\n", - "/*\n", - "Overlay with Shadow for Code Cell Selected !\n", - "*/\n", - "div.code_cell.selected,\n", - ".command_mode div.code_cell.jupyter-soft-selected {\n", - " box-shadow: 0 6px 18px #aaa;\n", - " z-index: 10;\n", - " top: -10px;\n", - "}\n", - "\n", - "div.code_cell.selected {\n", - " border: none;\n", - " background: transparent;\n", - "}\n", - "\n", - "div.prompt {\n", - " font-family: var(--txbk-code-font-family) !important;\n", - " font-style: normal;\n", - " font-size: 1rem;\n", - " text-align: right;\n", - " line-height: 1rem;\n", - " min-width: 9ex;\n", - "}\n", - "\n", - "div.cell.selected:before,\n", - "div.cell.jupyter-soft-selected:before {\n", - " /* Important Needed to Override */\n", - " width: 0 !important;\n", - " background: none !important;\n", - "}\n", - "\n", - "div.cell div.input:before {\n", - " display: inline-block;\n", - " position: relative;\n", - " content: \"\\279E\";\n", - " font-size: 1.8rem;\n", - " top: 11px;\n", - " width: 10px;\n", - " left: 3px;\n", - " font-weight: bold;\n", - "}\n", - "\n", - "div.cell:not(.selected) div.input:before {\n", - " color: var(--background-color);\n", - "}\n", - "\n", - "div.cell.selected:not(.jupyter-soft-selected) div.input:before {\n", - " color: var(--txbk-cell-display-border-color);\n", - "}\n", - "\n", - ".edit_mode div.cell.selected div.input:before,\n", - ".edit_mode div.cell.selected.unrendered div.input:before {\n", - " color: var(--txbk-cell-edit-border-color);\n", - "}\n", - "\n", - ".code_cell div.input_prompt:after,\n", - ".code_cell div.output_prompt:after {\n", - " display: inline-block;\n", - " content: '';\n", - " font-size: 0.75rem;\n", - " font-style: normal !important;\n", - "}\n", - "\n", - ".edit_mode div.cell.selected:before{\n", - " width: 0;\n", - " background: none;\n", - "}\n", - "\n", - "/* ==========================\n", - " Cell Input and Rendering\n", - " ==========================\n", - "*/\n", - "\n", - "div.input_area {\n", - " border-radius: 0;\n", - " border: none;\n", - " padding: 2px 5px 0 5px;\n", - "}\n", - "\n", - "div.input_prompt {\n", - " color: #aba9a9;\n", - " font-style: normal;\n", - " font-size: 1.4rem;\n", - " padding-top: 14px;\n", - "}\n", - "\n", - "/* FIX:\n", - " Fixing Empty cell output in HTML export\n", - "*/\n", - "div.output_prompt {\n", - " color: transparent !important;\n", - "}\n", - "\n", - "div.input_prompt bdi,\n", - "div.output_prompt bdi {\n", - " line-height: 0;\n", - " font-size:0;\n", - " color: transparent;\n", - " left: -10000px;\n", - " content: \"\\21E2\";\n", - "\n", - "}\n", - "\n", - "div.output_wrapper {\n", - " margin-top: 8px;\n", - "}\n", - "\n", - "div.output_area div.output_text pre,\n", - "div.output_area div.output_markdown p {\n", - " padding-bottom: 15px;\n", - " padding-top: 10px;\n", - "}\n", - "\n", - "div.output_area div.output_markdown p {\n", - " font-size: var(--txbk-content-font-size);\n", - "}\n", - "\n", - "div.output_area div.output_markdown pre code {\n", - " font-size: var(--txbk-content-mono-font-size);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "div.output_area div.output_text pre {\n", - " --txbk-content-mono-font-family: var(--txbk-code-font-family);\n", - "\n", - " font-weight: normal;\n", - " word-break: normal;\n", - " word-wrap: break-word;\n", - "}\n", - "\n", - "/* Output Standard Error */\n", - "div.output_stderr {\n", - " background-color: #FFFFFF;\n", - "}\n", - "\n", - "div.out_prompt_overlay:hover {\n", - " box-shadow: none;\n", - " background: none;\n", - "}\n", - "\n", - "/* Output HTML after cell code - e.g. Pandas DataFrame */\n", - "div.output_html {\n", - " color: var(--code-text-color);\n", - "}\n", - "\n", - "div.output_html a, div.output_html a:hover {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "div.output_html {\n", - " font-size: 1.4em;\n", - " font-weight: normal;\n", - " font-family: var(--txbk-code-font-family);\n", - "}\n", - "\n", - "div.output_html .nomono {\n", - " font-family: var(--txbk-content-font-family);\n", - " margin-top: 0;\n", - " font-size: 1em;\n", - "}\n", - "\n", - "div.output_html > iframe, div.output_area {\n", - " margin-left: 2rem;\n", - "}\n", - "\n", - "div.output_subarea {\n", - " margin-left: 0;\n", - "}\n", - "\n", - "div.output_svg div {\n", - " max-width: 98%;\n", - " margin-left: 0 !important;\n", - "}\n", - "\n", - "/* ----------------------------\n", - " Override default CSS rules\n", - " ---------------------------- */\n", - ".rendered_html code {\n", - " background-color: transparent !important;\n", - "}\n", - "\n", - ".rendered_html h1:first-child,\n", - ".rendered_html h2:first-child,\n", - ".rendered_html h3:first-child,\n", - ".rendered_html h4:first-child,\n", - ".rendered_html h5:first-child,\n", - ".rendered_html h6:first-child {\n", - " margin-top: 0.25em;\n", - "}\n", - "\n", - ".rendered_html h1 {\n", - " margin-top: 0.48em;\n", - "}\n", - "\n", - ".rendered_html h2 {\n", - " margin-top: 0.57em;\n", - "}\n", - "\n", - ".rendered_html h3 {\n", - " margin-top: 0.85em;\n", - "}\n", - "\n", - ".rendered_html h4 {\n", - " margin-top: 1.3em;\n", - "}\n", - "\n", - ".rendered_html h5 {\n", - " margin-top: 1.2em;\n", - "}\n", - "\n", - ".rendered_html h6 {\n", - " margin-top: 1.1em;\n", - "}\n", - "\n", - "/* ===============\n", - " CELLS Render\n", - " =============== */\n", - "\n", - "/* -------------------------\n", - " (1) CODE CELLS\n", - " Display + Edit modes\n", - " -------------------------\n", - "*/\n", - "div.code_cell pre, div.CodeMirror, div.CodeMirror-linenumber {\n", - " font-family: var(--txbk-code-font-family);\n", - " font-size: var(--txbk-code-font-size);\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - "div.CodeMirror-linenumber {\n", - " --txbk-ui-mono-font-size: 12px !important;\n", - "}\n", - "\n", - "/* -- MARKDOWN CELLS (Edit) -- */\n", - "\n", - "/* md cell */\n", - "div.text_cell.unrendered pre {\n", - " /* general font rule */\n", - " font-family: var(--txbk-md-font-family);\n", - " font-size: var(--txbk-md-font-size);\n", - " line-height: var(--txbk-code-line-height);\n", - "}\n", - "\n", - "/* md cell headers (edit) */\n", - ".cm-header-1, .cm-header-2, .cm-header-3,\n", - ".cm-header-4, .cm-header-5, .cm-header-6 {\n", - " /* general font rule */\n", - " font-family: var(--txbk-md-font-family);\n", - "}\n", - "\n", - "/* ------------------------------------------------------------------\n", - " (2) MARKDOWN CELLS (DISPLAY MODE)\n", - "\n", - " Notes: Font-families to use here:\n", - " computer-modern --> general text (Computer Modern Typeface, CMU)\n", - " md-display-monospace --> Monospace output (CMU Typewriter)\n", - " ------------------------------------------------------------------\n", - " */\n", - "\n", - "div.text_cell_render {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-size: var(--txbk-content-font-size);\n", - " color: var(--txbk-content-color);\n", - " font-kerning: auto;\n", - " text-align: justify;\n", - " display: block;\n", - " word-break: normal;\n", - " word-wrap: break-word;\n", - "}\n", - "\n", - "div.text_cell_render a, div.text_cell_render a:hover {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "div.text_cell_render h1, div.text_cell_render h2,\n", - "div.text_cell_render h3, div.text_cell_render h4,\n", - "div.text_cell_render h5, div.text_cell_render h6 {\n", - " font-family: var(--txbk-content-font-family);\n", - " font-style: normal;\n", - "}\n", - "\n", - "/* Font-sizes for headers */\n", - "div.text_cell_render h1 {\n", - " font-size: 2.2em;\n", - " text-align: center;\n", - " padding-top: 3rem;\n", - " padding-bottom: 3rem;\n", - "}\n", - "\n", - "div.text_cell_render h2 {\n", - " font-size: 1.9em;\n", - "}\n", - "\n", - "div.text_cell_render h3 {\n", - " font-size: 1.7em;\n", - "}\n", - "\n", - "div.text_cell_render h4 {\n", - " font-size: 1.5em;\n", - "}\n", - "\n", - "div.text_cell_render h5 {\n", - " font-size: 1.3em;\n", - " border-bottom: 1px solid rgb(204, 204, 204);\n", - "}\n", - "\n", - "div.text_cell_render h6 {\n", - " font-size: 1.1em;\n", - "}\n", - "\n", - "div.text_cell_render p,\n", - "div.text_cell_render pre,\n", - "div.text_cell_render code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "div.text_cell_render pre,\n", - "div.text_cell_render code {\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "/* Monospace Code - no code syntax highlight*/\n", - "div.text_cell_render pre {\n", - " /* hack: using code background colour here to allow for compatibility */\n", - " background-color: var(--code-background-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "div.text_cell_render p {\n", - " line-height: var(--txbk-content-line-height);\n", - " text-align: justify !important;\n", - "}\n", - "\n", - "div.text_cell_render code {\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "/* Monospace inline rendered markdown */\n", - "div.text_cell_render p code {\n", - " /*Re-defining variables for Mono using Code Editor's settings*/\n", - " /*--txbk-content-mono-font-family: var(--txbk-code-font-family);*/\n", - " /*--txbk-content-mono-font-size: var(--txbk-code-font-size);*/\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " color: var(--txbk-content-mono-color);\n", - " font-family: var(--txbk-content-mono-font-family);\n", - "}\n", - "\n", - "div.text_cell_render p strong code {\n", - " font-weight: bold !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "div.text_cell_render p em code {\n", - " font-style: italic !important;\n", - " color: var(--txbk-content-mono-color);\n", - "}\n", - "\n", - "div.text_cell_render pre code {\n", - " padding: 1rem 1.5rem;\n", - " display: block !important;\n", - " color: var(--txbk-content-mono-color);\n", - " background-color: var(--txbk-content-mono-bgcolor) !important;\n", - " font-family: var(--txbk-content-mono-font-family);\n", - " font-size: var(--txbk-content-mono-font-size) !important;\n", - " word-wrap: break-word;\n", - " word-break: normal;\n", - "}\n", - "\n", - "div.text_cell_render blockquote {\n", - " --txbk-ui-color: #6f6f6f;\n", - " margin: .2rem .2rem;\n", - " padding: .3rem .5rem;\n", - " border-left: .3rem solid #a7a7a7;\n", - " background-color: var(--txbk-content-mono-bgcolor);\n", - "}\n", - "\n", - "div.text_cell_render blockquote:not(:first-child) {\n", - " margin: 2rem .2rem;\n", - "}\n", - "\n", - "div.text_cell_render blockquote p {\n", - " padding: .2rem 1.5rem;\n", - "}\n", - "\n", - "div.text_cell_render table {\n", - " font-size: var(--txbk-content-font-size) !important;\n", - " border-collapse: collapse;\n", - " border-spacing: 0;\n", - " overflow: auto;\n", - " break-inside: auto;\n", - " margin-top: 25px;\n", - " margin-bottom: 15px;\n", - "}\n", - "\n", - "div.text_cell_render table thead {\n", - " display: table-header-group;\n", - " vertical-align: middle;\n", - " border-bottom: none;\n", - "}\n", - "\n", - "div.text_cell_render table thead tr,\n", - "div.text_cell_render table thead tr th,\n", - "div.text_cell_render table thead tr td,\n", - "div.text_cell_render table tbody tr,\n", - "div.text_cell_render table tbody tr th,\n", - "div.text_cell_render table tbody tr td {\n", - " break-inside: avoid;\n", - " break-after: auto;\n", - " vertical-align: middle;\n", - " padding: 5px 5px;\n", - "}\n", - "\n", - "div.text_cell_render table tr th {\n", - " border-bottom-width: 0;\n", - "}\n", - "\n", - "div.text_cell_render ul, div.text_cell_render ol {\n", - " position: relative;\n", - " display: block;\n", - " margin-bottom: 0 !important;\n", - " line-height: var(--txbk-content-line-height);\n", - "}\n", - "\n", - "div.text_cell_render ul {\n", - " list-style-type: disc;\n", - "}\n", - "\n", - "div.text_cell_render ul li, div.text_cell_render ol li {\n", - " padding: .25em;\n", - "}\n", - "\n", - "div.text_cell_render ul ul {\n", - " list-style-type: circle !important;\n", - "}\n", - "\n", - "div.text_cell_render ul li > ul li a code,\n", - "div.text_cell_render ul li > ol li a code,\n", - "div.text_cell_render ol li > ul li a code,\n", - "div.text_cell_render ol li > ol li a code {\n", - " color: var(--link-color);\n", - "}\n", - "\n", - "div.text_cell_render ul ul ul {\n", - " list-style-type: square !important;\n", - "}\n", - "\n", - "div.text_cell_render p > img:only-child {\n", - " display: block;\n", - " margin: auto;\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - "div.text_cell_render img {\n", - " max-width: 70%;\n", - "}\n", - "\n", - "/*\n", - " ===================================\n", - " New CSS Classes and Styles\n", - " ===================================\n", - "\n", - " --------------\n", - " 1. Footnotes\n", - " --------------\n", - "*/\n", - "[id^='fn'], [class^='fn'] {\n", - " font-size: small !important;\n", - " font-weight: normal !important;\n", - " font-style: normal !important;\n", - " border-top: 1px solid var(--txbk-ui-mono-color);\n", - " padding-top: .8rem;\n", - " display: block;\n", - "}\n", - "\n", - "p > [id^='fn']:not(:first-child),\n", - "p > [class^='fn']:not(:first-child) {\n", - " border-top: 0 !important;\n", - "}\n", - "\n", - "[id^='fn'] i, [class^='fn'] i,\n", - "[id^='fn'] b, [class^='fn'] b,\n", - "[id^='fn'] strong, [class^='fn'] strong,\n", - "p > strong > strong {\n", - " background-color: var(--txbk-content-mono-bgcolor);\n", - " font-style: normal !important;\n", - " font-weight: bold !important;\n", - "}\n", - "\n", - "/* FIX Forcing monospace code to adhere with footnotes rules!*/\n", - "div.text_cell_render p [id^='fn'] > code,\n", - "div.text_cell_render p [class^='fn'] > code {\n", - " font-size: 1em !important;\n", - "}\n", - "\n", - "/* CSS Anchors link as superscript (like footnotes) */\n", - "a[href^=\"#fn\"], a[href*=\"fn\"] {\n", - " font-size: 60%;\n", - " vertical-align: top;\n", - "}\n", - "/* Surround Footnotes by Square brackets */\n", - "a[href^=\"#fn\"]:before, a[href*=\"fn\"]:before {\n", - " content: \"[\";\n", - "}\n", - "\n", - "a[href^=\"#fn\"]:after, a[href*=\"fn\"]:after {\n", - " content: \"]\";\n", - "}\n", - "\n", - "/* --------------\n", - " 2. Drop cap\n", - " --------------\n", - "*/\n", - ".drop {\n", - " color: var(--drop-cap-color);\n", - " font-size: 75px;\n", - " line-height: 60px;\n", - " padding-top: 4px;\n", - " margin-top: 0.2rem;\n", - "}\n", - "\n", - "/* -----------------------------\n", - " 3. noTeXbook Text colours\n", - " -----------------------------\n", - "*/\n", - ".texbook-red {\n", - " color: var(--texbook-red);\n", - "}\n", - "\n", - ".texbook-pink {\n", - " color: var(--texbook-pink);\n", - "}\n", - "\n", - ".texbook-turquoise {\n", - " color: var(--texbook-turquoise);\n", - "}\n", - "\n", - ".texbook-azure {\n", - " color: var(--texbook-azure);\n", - "}\n", - "\n", - ".texbook-blue {\n", - " color: var(--texbook-blue);\n", - "}\n", - "\n", - ".texbook-light-grey {\n", - " color: var(--texbook-light-grey);\n", - "}\n", - "\n", - ".texbook-dark-grey {\n", - " color: var(--texbook-dark-grey);\n", - "}\n", - "\n", - ".texbook-orange {\n", - " color: var(--texbook-orange);\n", - "}\n", - "\n", - ".texbook-yellow {\n", - " color: var(--texbook-yellow);\n", - "}\n", - "\n", - "/* ---------------------------------------------------------\n", - " 4. IMG MaxWidthXX\n", - "\n", - " CSS classes to control the max-width property of images\n", - " when the default 70% is not enough.\n", - " This is when images need to be enlarged or shrunk.\n", - " ---------------------------------------------------------\n", - "*/\n", - "\n", - "div.text_cell_render img.maxw10,\n", - "div.text_cell_render p > img.maxw10 {\n", - " max-width: 10% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw15,\n", - "div.text_cell_render p > img.maxw15 {\n", - " max-width: 15% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw20,\n", - "div.text_cell_render p > img.maxw20 {\n", - " max-width: 20% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw25,\n", - "div.text_cell_render p > img.maxw25 {\n", - " max-width: 25% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw30,\n", - "div.text_cell_render p > img.maxw30 {\n", - " max-width: 30% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw35,\n", - "div.text_cell_render p > img.maxw35 {\n", - " max-width: 35% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw40,\n", - "div.text_cell_render p > img.maxw40 {\n", - " max-width: 40% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw45,\n", - "div.text_cell_render p > img.maxw45 {\n", - " max-width: 45% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw50,\n", - "div.text_cell_render p > img.maxw50 {\n", - " max-width: 50% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw55,\n", - "div.text_cell_render p > img.maxw55 {\n", - " max-width: 55% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw60,\n", - "div.text_cell_render p > img.maxw60 {\n", - " max-width: 60% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw65,\n", - "div.text_cell_render p > img.maxw65 {\n", - " max-width: 65% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw70,\n", - "div.text_cell_render p > img.maxw70 {\n", - " max-width: 70% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw75,\n", - "div.text_cell_render p > img.maxw75 {\n", - " max-width: 75% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw80,\n", - "div.text_cell_render p > img.maxw80 {\n", - " max-width: 80% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw85,\n", - "div.text_cell_render p > img.maxw85 {\n", - " max-width: 85% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw90,\n", - "div.text_cell_render p > img.maxw90 {\n", - " max-width: 90% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw95,\n", - "div.text_cell_render p > img.maxw95 {\n", - " max-width: 95% !important;\n", - "}\n", - "\n", - "div.text_cell_render img.maxw100,\n", - "div.text_cell_render p > img.maxw100 {\n", - " max-width: 100% !important;\n", - "}\n", - "\n", - "/* ------------\n", - " 4. Badges\n", - " ------------\n", - "*/\n", - ".badges img, .badges p img {\n", - " margin: 0 !important; /* Override margins */\n", - " display: inline !important;\n", - " padding-right: 7px;\n", - "}\n", - "\n", - ".badges p {\n", - " display: inline !important;\n", - "}\n", - "\n", - ".badges {\n", - " display: block;\n", - " text-align: center;\n", - "}\n", - "\n", - "/* ----------------\n", - " 5. Inline Math\n", - " ----------------\n", - "*/\n", - ".inline-math {\n", - " display: inline-block;\n", - "}\n", - "\n", - "/* --------------------\n", - " 6. Inline Mono Font\n", - " --------------------\n", - "*/\n", - ".codemono code, .codemono pre, .codemono pre code {\n", - " font-family: var(--txbk-code-font-family) !important;\n", - "}\n", - "\n", - ".mdmono code, .mdmono pre, .mdmono pre code {\n", - " font-family: var(--txbk-md-font-family) !important;\n", - "}\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " The notebook is using\n", - " \n", - " no$\\TeX$book Jupyter Theme (release 2.0.1).\n", - "\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Optional: setup NoTexBook theme\n", - "%load_ext notexbook\n", - "\n", - "%texify" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "94840512-1a02-4806-91a4-1a2ee8532b91", - "metadata": {}, - "outputs": [], - "source": [ - "# UNCOMMENT THIS ONLY if running on Anaconda Notebooks and if needed\n", - "# Note: Same modules as in MIA related notebooks!\n", - "\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/dataset.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/models.py\n", - "# !wget https://raw.githubusercontent.com/leriomaggio/ppml-tutorial/main/3-ml-models-attacks/train.py" - ] - }, - { - "cell_type": "markdown", - "id": "f5f5b821", - "metadata": {}, - "source": [ - "# Model Inversion Attack" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "68655027", - "metadata": {}, - "outputs": [], - "source": [ - "import torch as th\n", - "import numpy as np\n", - "\n", - "from matplotlib import pyplot as plt\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "45779d5a", - "metadata": {}, - "outputs": [], - "source": [ - "from dataset import ORLFaces\n", - "from torchvision.transforms import ToTensor" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3d5132ab", - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n", - "# see, https://github.com/pytorch/vision/issues/3497 for more information\n", - "from six.moves import urllib\n", - "\n", - "opener = urllib.request.build_opener()\n", - "opener.addheaders = [(\"User-agent\", \"Mozilla/5.0\")]\n", - "urllib.request.install_opener(opener)\n", - "\n", - "from pathlib import Path\n", - "import os\n", - "\n", - "DATA_FOLDER = Path(os.path.join(os.path.abspath(os.path.curdir), \"..\")) / \"data\"" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "4db6abf3", - "metadata": {}, - "outputs": [], - "source": [ - "orl_faces_train = ORLFaces(\n", - " root=DATA_FOLDER, download=True, split=\"train\", transform=ToTensor()\n", - ")\n", - "orl_faces_test = ORLFaces(root=DATA_FOLDER, download=True, split=\"test\", transform=ToTensor())" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d0d51644", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([280, 112, 92]), torch.Size([120, 112, 92]))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "orl_faces_train.data.shape, orl_faces_test.data.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "859989b5", - "metadata": {}, - "outputs": [], - "source": [ - "from torch.utils.data import DataLoader\n", - "\n", - "train_loader = DataLoader(\n", - " orl_faces_train, batch_size=32, shuffle=False, drop_last=False\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c8c16f84", - "metadata": {}, - "outputs": [], - "source": [ - "# Reconstruction Attack Settings\n", - "# See Paper, Section 5.2 - Reconstruction Attack\n", - "α = 5000\n", - "β = 100\n", - "γ = 0.99\n", - "λ = 0.1" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "39426d25", - "metadata": {}, - "outputs": [], - "source": [ - "from models import SoftmaxRegression, MLP" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "34de5f7f", - "metadata": {}, - "outputs": [], - "source": [ - "from pathlib import Path\n", - "\n", - "CHECKPOINT_FOLDER = Path(\"./checkpoints/\")\n", - "\n", - "\n", - "def load_weights(model, model_name: str = None) -> th.TensorType:\n", - " if model_name is None or not model_name:\n", - " model_name = model.__class__.__name__.lower()\n", - " w_file = CHECKPOINT_FOLDER / f\"{model_name}.pt\"\n", - " try:\n", - " weights = th.load(open(w_file, \"rb\"))\n", - " except FileNotFoundError:\n", - " print(f\"Model Weights file {w_file} does not exist! Please check.\")\n", - " return None\n", - " return weights" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "d37c65ad", - "metadata": {}, - "outputs": [], - "source": [ - "softmax_reg = SoftmaxRegression()\n", - "weights = load_weights(softmax_reg, model_name=\"softmax_reg_opacus_test\")\n", - "\n", - "weights[\"regression.weight\"] = weights[\"_module.regression.weight\"]\n", - "_ = weights.pop(\"_module.regression.weight\")\n", - "\n", - "weights[\"regression.bias\"] = weights[\"_module.regression.bias\"]\n", - "_ = weights.pop(\"_module.regression.bias\")\n", - "\n", - "if weights is not None:\n", - " softmax_reg.load_state_dict(weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "81e83c5b", - "metadata": {}, - "outputs": [], - "source": [ - "def process(im_flatten):\n", - " max_v = th.max(im_flatten)\n", - " min_v = th.min(im_flatten)\n", - " return (im_flatten - min_v) / (max_v - min_v)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "e52a0ac1", - "metadata": {}, - "outputs": [], - "source": [ - "def mi_face(model, target_label):\n", - " aim_tensor = th.zeros(1, 112 * 92)\n", - " aim_tensor.requires_grad = True\n", - "\n", - " lossn_1 = 10\n", - " b = 0\n", - " g = 0\n", - "\n", - " out = model(aim_tensor.detach())\n", - " _, pred = th.max(out, 1)\n", - " print(pred)\n", - " print(f\"original input image {target_label}\")\n", - " plt.imshow(\n", - " np.transpose(aim_tensor.detach().reshape(1, 112, 92).numpy(), (1, 2, 0)),\n", - " cmap=\"Greys\",\n", - " )\n", - " plt.show()\n", - " print(\n", - " f\"original input image predict label {target_label} - predict label: {pred.item()}\"\n", - " )\n", - "\n", - " criterion = th.nn.NLLLoss()\n", - "\n", - " for i in range(α):\n", - " out = model(aim_tensor)\n", - " if aim_tensor.grad is not None:\n", - " aim_tensor.grad.zero_()\n", - " out = out.reshape(1, 40)\n", - " target_class = th.tensor([target_label])\n", - " loss = criterion(out, target_class)\n", - " loss.backward()\n", - " aim_grad = aim_tensor.grad\n", - "\n", - " # SGD Step\n", - " # see https://pytorch.org/docs/stable/generated/torch.optim.SGD.html#torch.optim.SGD\n", - " aim_tensor = aim_tensor - (λ * aim_grad)\n", - " aim_tensor = process(aim_tensor)\n", - " aim_tensor = th.clamp(aim_tensor.detach(), 0, 1)\n", - " aim_tensor.requires_grad = True\n", - " if loss >= lossn_1:\n", - " b += 1\n", - " if b > β:\n", - " break\n", - " else:\n", - " b = 0\n", - " lossn_1 = loss\n", - " if loss < γ:\n", - " break\n", - "\n", - " print(f\"Attack completed at {i} iterations\")\n", - " out = model(aim_tensor.detach())\n", - " _, pred = th.max(out, 1)\n", - " print(pred)\n", - " print(f\"inverted image {target_label}\")\n", - " plt.imshow(\n", - " np.transpose(aim_tensor.detach().reshape(1, 112, 92).numpy() * 255, (1, 2, 0)),\n", - " cmap=\"Greys\",\n", - " )\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "44013f2f", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 0 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([0])\n", - "inverted image 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 1 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([1])\n", - "inverted image 1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 2\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWcAAAGhCAYAAAC9CXUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAZcUlEQVR4nO3cf2zVV/3H8delhUuL7XVAuJcrP1aSJsDKHCuT2OFaw6hxOCXE/YJtLDOGWdi4q65QmY4RuRdQkbg6CMQwDCLECIrGH9RNy7AqXbdurDPgsgqVcVOn9d4yulbo+f5B+OR7V3DM3XLft30+kvvHPZ/T23dPyHOf3d7U55xzAgCYMizTAwAA+iPOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYFBG4/z000+rqKhII0eOVGlpqZ5//vlMjgMAZmQsznv37lUkEtHq1av10ksv6ROf+IQ+/elP6+TJk5kaCQDM8GXqDx/Nnj1bN954o7Zs2eKtTZs2TQsWLFAsFvuvX9vX16c333xTBQUF8vl8Az0qAKSNc05dXV0Kh8MaNuzy98e5V3EmT29vr5qbm7Vq1aqU9crKSjU2Nvbb39PTo56eHu/5qVOnNH369AGfEwAGSnt7uyZMmHDZ6xmJ81tvvaXz588rGAymrAeDQcXj8X77Y7GYnnzyyX7r7e3tKiwsHLA5ASDdksmkJk6cqIKCgv+6LyNxvujdb0k45y75NkVtba2qq6u95xd/uMLCQuIMICu911uyGYnz2LFjlZOT0+8uuaOjo9/dtCT5/X75/f6rNR4AZFxGPq0xYsQIlZaWqr6+PmW9vr5eZWVlmRgJAEzJ2Nsa1dXVuu+++zRr1ix9/OMf17Zt23Ty5Ek99NBDmRoJAMzIWJzvuusu/fOf/9TatWt1+vRplZSU6Je//KUmT56cqZEAwIyMfc75g0gmkwoEAkokEvxCEEBWudJ+8bc1AMAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudYLKabbrpJBQUFGjdunBYsWKBjx46l7HHOac2aNQqHw8rLy1NFRYVaW1vTPQoAZK20x7mhoUHLli3Tn/70J9XX1+vcuXOqrKzU22+/7e3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjk3kN/gH//4h8aNG6eGhgbdcsstcs4pHA4rEolo5cqVkqSenh4Fg0Ft2LBBS5cufc/XTCaTCgQCSiQSKiwsHMjxASCtrrRfA/6ecyKRkCSNHj1aktTW1qZ4PK7Kykpvj9/vV3l5uRobGy/5Gj09PUomkykPABjMBjTOzjlVV1drzpw5KikpkSTF43FJUjAYTNkbDAa9a+8Wi8UUCAS8x8SJEwdybADIuAGN8/Lly/XKK6/oRz/6Ub9rPp8v5blzrt/aRbW1tUokEt6jvb19QOYFACtyB+qFH374YR04cECHDh3ShAkTvPVQKCTpwh30+PHjvfWOjo5+d9MX+f1++f3+gRoVAMxJ+52zc07Lly/Xvn379Nxzz6moqCjlelFRkUKhkOrr67213t5eNTQ0qKysLN3jAEBWSvud87Jly7R792797Gc/U0FBgfc+ciAQUF5ennw+nyKRiKLRqIqLi1VcXKxoNKr8/HwtWrQo3eMAQFZKe5y3bNkiSaqoqEhZ37Fjhx544AFJUk1Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCsNOCfcx4IfM4ZQLYy8zlnAMD7R5wBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGDQgMc5FovJ5/MpEol4a845rVmzRuFwWHl5eaqoqFBra+tAjwIAWWNA49zU1KRt27bp+uuvT1nfuHGjNm3apLq6OjU1NSkUCmnevHnq6uoayHEAIGsMWJzPnDmjxYsXa/v27brmmmu8deecNm/erNWrV2vhwoUqKSnRzp07dfbsWe3evXugxgGArDJgcV62bJnmz5+vW2+9NWW9ra1N8XhclZWV3prf71d5ebkaGxsv+Vo9PT1KJpMpDwAYzHIH4kX37NmjF198UU1NTf2uxeNxSVIwGExZDwaDOnHixCVfLxaL6cknn0z/oABgVNrvnNvb27VixQrt2rVLI0eOvOw+n8+X8tw512/totraWiUSCe/R3t6e1pkBwJq03zk3Nzero6NDpaWl3tr58+d16NAh1dXV6dixY5Iu3EGPHz/e29PR0dHvbvoiv98vv9+f7lEBwKy03znPnTtXR48eVUtLi/eYNWuWFi9erJaWFk2ZMkWhUEj19fXe1/T29qqhoUFlZWXpHgcAslLa75wLCgpUUlKSsjZq1CiNGTPGW49EIopGoyouLlZxcbGi0ajy8/O1aNGidI8DAFlpQH4h+F5qamrU3d2tqqoqdXZ2avbs2Tp48KAKCgoyMQ4AmONzzrlMD/F+JZNJBQIBJRIJFRYWZnocALhiV9ov/rYGABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYNCAxPnUqVO69957NWbMGOXn5+uGG25Qc3Ozd905pzVr1igcDisvL08VFRVqbW0diFEAICulPc6dnZ26+eabNXz4cP3qV7/Sa6+9pm9/+9v68Ic/7O3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjmXzhdctWqV/vCHP+j555+/5HXnnMLhsCKRiFauXClJ6unpUTAY1IYNG7R06dL3/B7JZFKBQECJREKFhYXpHB8ABtSV9ivtd84HDhzQrFmzdMcdd2jcuHGaOXOmtm/f7l1va2tTPB5XZWWlt+b3+1VeXq7GxsZLvmZPT4+SyWTKAwAGs7TH+Y033tCWLVtUXFys3/zmN3rooYf0yCOP6Ac/+IEkKR6PS5KCwWDK1wWDQe/au8ViMQUCAe8xceLEdI8NAKakPc59fX268cYbFY1GNXPmTC1dulRf/OIXtWXLlpR9Pp8v5blzrt/aRbW1tUokEt6jvb093WMDgClpj/P48eM1ffr0lLVp06bp5MmTkqRQKCRJ/e6SOzo6+t1NX+T3+1VYWJjyAIDBLO1xvvnmm3Xs2LGUtePHj2vy5MmSpKKiIoVCIdXX13vXe3t71dDQoLKysnSPAwBZKTfdL/joo4+qrKxM0WhUd955p44cOaJt27Zp27Ztki68nRGJRBSNRlVcXKzi4mJFo1Hl5+dr0aJF6R4HALJS2uN80003af/+/aqtrdXatWtVVFSkzZs3a/Hixd6empoadXd3q6qqSp2dnZo9e7YOHjyogoKCdI8DAFkp7Z9zvhr4nDOAbJWxzzkDAD444gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudz587p8ccfV1FRkfLy8jRlyhStXbtWfX193h7nnNasWaNwOKy8vDxVVFSotbU13aMAQNZKe5w3bNigrVu3qq6uTn/5y1+0ceNGffOb39RTTz3l7dm4caM2bdqkuro6NTU1KRQKad68eerq6kr3OACQldIe5z/+8Y/63Oc+p/nz5+vaa6/V5z//eVVWVuqFF16QdOGuefPmzVq9erUWLlyokpIS7dy5U2fPntXu3bvTPQ4AZKW0x3nOnDl69tlndfz4cUnSyy+/rMOHD+u2226TJLW1tSkej6uystL7Gr/fr/LycjU2Nl7yNXt6epRMJlMeADCY5ab7BVeuXKlEIqGpU6cqJydH58+f17p163TPPfdIkuLxuCQpGAymfF0wGNSJEycu+ZqxWExPPvlkukcFALPSfue8d+9e7dq1S7t379aLL76onTt36lvf+pZ27tyZss/n86U8d871W7uotrZWiUTCe7S3t6d7bAAwJe13zo899phWrVqlu+++W5I0Y8YMnThxQrFYTEuWLFEoFJJ04Q56/Pjx3td1dHT0u5u+yO/3y+/3p3tUADAr7XfOZ8+e1bBhqS+bk5PjfZSuqKhIoVBI9fX13vXe3l41NDSorKws3eMAQFZK+53z7bffrnXr1mnSpEm67rrr9NJLL2nTpk168MEHJV14OyMSiSgajaq4uFjFxcWKRqPKz8/XokWL0j0OAGSltMf5qaee0te+9jVVVVWpo6ND4XBYS5cu1de//nVvT01Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCs5HPOuUwP8X4lk0kFAgElEgkVFhZmehwAuGJX2i/+tgYAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBg0PuO86FDh3T77bcrHA7L5/Pppz/9acp155zWrFmjcDisvLw8VVRUqLW1NWVPT0+PHn74YY0dO1ajRo3SZz/7Wf3973//QD8IAAwm7zvOb7/9tj760Y+qrq7uktc3btyoTZs2qa6uTk1NTQqFQpo3b566urq8PZFIRPv379eePXt0+PBhnTlzRp/5zGd0/vz5//0nAYDBxH0Aktz+/fu95319fS4UCrn169d7a++8844LBAJu69atzjnn/v3vf7vhw4e7PXv2eHtOnTrlhg0b5n79619f0fdNJBJOkkskEh9kfAC46q60X2l9z7mtrU3xeFyVlZXemt/vV3l5uRobGyVJzc3N+s9//pOyJxwOq6SkxNvzbj09PUomkykPABjM0hrneDwuSQoGgynrwWDQuxaPxzVixAhdc801l93zbrFYTIFAwHtMnDgxnWMDgDkD8mkNn8+X8tw512/t3f7bntraWiUSCe/R3t6etlkBwKK0xjkUCklSvzvgjo4O7246FAqpt7dXnZ2dl93zbn6/X4WFhSkPABjM0hrnoqIihUIh1dfXe2u9vb1qaGhQWVmZJKm0tFTDhw9P2XP69Gm9+uqr3h4AGOpy3+8XnDlzRq+//rr3vK2tTS0tLRo9erQmTZqkSCSiaDSq4uJiFRcXKxqNKj8/X4sWLZIkBQIBfeELX9CXv/xljRkzRqNHj9ZXvvIVzZgxQ7feemv6fjIAyGLvO84vvPCCPvnJT3rPq6urJUlLlizRM888o5qaGnV3d6uqqkqdnZ2aPXu2Dh48qIKCAu9rvvOd7yg3N1d33nmnuru7NXfuXD3zzDPKyclJw48EANnP55xzmR7i/UomkwoEAkokErz/DCCrXGm/+NsaAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwKDfTA/wvnHOSpGQymeFJAOD9uditix27nKyMc1dXlyRp4sSJGZ4EAP43XV1dCgQCl73uc++Vb4P6+vr05ptvyjmnSZMmqb29XYWFhZkeK2OSyaQmTpzIOXAOkjiHi6yeg3NOXV1dCofDGjbs8u8sZ+Wd87BhwzRhwgTvfw8KCwtNHX6mcA4XcA4XcA4XWDyH/3bHfBG/EAQAg4gzABiU1XH2+/164okn5Pf7Mz1KRnEOF3AOF3AOF2T7OWTlLwQBYLDL6jtnABisiDMAGEScAcAg4gwABmVtnJ9++mkVFRVp5MiRKi0t1fPPP5/pkQZULBbTTTfdpIKCAo0bN04LFizQsWPHUvY457RmzRqFw2Hl5eWpoqJCra2tGZr46ojFYvL5fIpEIt7aUDmHU6dO6d5779WYMWOUn5+vG264Qc3Nzd71oXAO586d0+OPP66ioiLl5eVpypQpWrt2rfr6+rw9WXsOLgvt2bPHDR8+3G3fvt299tprbsWKFW7UqFHuxIkTmR5twHzqU59yO3bscK+++qpraWlx8+fPd5MmTXJnzpzx9qxfv94VFBS4n/zkJ+7o0aPurrvucuPHj3fJZDKDkw+cI0eOuGuvvdZdf/31bsWKFd76UDiHf/3rX27y5MnugQcecH/+859dW1ub++1vf+tef/11b89QOIdvfOMbbsyYMe4Xv/iFa2trcz/+8Y/dhz70Ibd582ZvT7aeQ1bG+WMf+5h76KGHUtamTp3qVq1alaGJrr6Ojg4nyTU0NDjnnOvr63OhUMitX7/e2/POO++4QCDgtm7dmqkxB0xXV5crLi529fX1rry83IvzUDmHlStXujlz5lz2+lA5h/nz57sHH3wwZW3hwoXu3nvvdc5l9zlk3dsavb29am5uVmVlZcp6ZWWlGhsbMzTV1ZdIJCRJo0ePliS1tbUpHo+nnIvf71d5efmgPJdly5Zp/vz5uvXWW1PWh8o5HDhwQLNmzdIdd9yhcePGaebMmdq+fbt3faicw5w5c/Tss8/q+PHjkqSXX35Zhw8f1m233SYpu88h6/7w0VtvvaXz588rGAymrAeDQcXj8QxNdXU551RdXa05c+aopKREkryf/VLncuLEias+40Das2ePXnzxRTU1NfW7NlTO4Y033tCWLVtUXV2tr371qzpy5IgeeeQR+f1+3X///UPmHFauXKlEIqGpU6cqJydH58+f17p163TPPfdIyu5/D1kX54t8Pl/Kc+dcv7XBavny5XrllVd0+PDhftcG+7m0t7drxYoVOnjwoEaOHHnZfYP9HPr6+jRr1ixFo1FJ0syZM9Xa2qotW7bo/vvv9/YN9nPYu3evdu3apd27d+u6665TS0uLIpGIwuGwlixZ4u3LxnPIurc1xo4dq5ycnH53yR0dHf3+6zgYPfzwwzpw4IB+97vfacKECd56KBSSpEF/Ls3Nzero6FBpaalyc3OVm5urhoYGffe731Vubq73sw72cxg/frymT5+esjZt2jSdPHlS0tD59/DYY49p1apVuvvuuzVjxgzdd999evTRRxWLxSRl9zlkXZxHjBih0tJS1dfXp6zX19errKwsQ1MNPOecli9frn379um5555TUVFRyvWioiKFQqGUc+nt7VVDQ8OgOpe5c+fq6NGjamlp8R6zZs3S4sWL1dLSoilTpgyJc7j55pv7fZTy+PHjmjx5sqSh8+/h7Nmz/f5gfU5OjvdRuqw+hwz+MvJ/dvGjdN///vfda6+95iKRiBs1apT729/+lunRBsyXvvQlFwgE3O9//3t3+vRp73H27Flvz/r1610gEHD79u1zR48edffcc09WfGTog/r/n9Zwbmicw5EjR1xubq5bt26d++tf/+p++MMfuvz8fLdr1y5vz1A4hyVLlriPfOQj3kfp9u3b58aOHetqamq8Pdl6DlkZZ+ec+973vucmT57sRowY4W688UbvI2WDlaRLPnbs2OHt6evrc0888YQLhULO7/e7W265xR09ejRzQ18l747zUDmHn//8566kpMT5/X43depUt23btpTrQ+EcksmkW7FihZs0aZIbOXKkmzJlilu9erXr6enx9mTrOfAnQwHAoKx7zxkAhgLiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEH/B9l3Kld+JNUoAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 2 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([2])\n", - "inverted image 2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 3 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([3])\n", - "inverted image 3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 4 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([4])\n", - "inverted image 4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 5\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 5 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([5])\n", - "inverted image 5\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 6\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWcAAAGhCAYAAAC9CXUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAZcUlEQVR4nO3cf2zVV/3H8delhUuL7XVAuJcrP1aSJsDKHCuT2OFaw6hxOCXE/YJtLDOGWdi4q65QmY4RuRdQkbg6CMQwDCLECIrGH9RNy7AqXbdurDPgsgqVcVOn9d4yulbo+f5B+OR7V3DM3XLft30+kvvHPZ/T23dPyHOf3d7U55xzAgCYMizTAwAA+iPOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYFBG4/z000+rqKhII0eOVGlpqZ5//vlMjgMAZmQsznv37lUkEtHq1av10ksv6ROf+IQ+/elP6+TJk5kaCQDM8GXqDx/Nnj1bN954o7Zs2eKtTZs2TQsWLFAsFvuvX9vX16c333xTBQUF8vl8Az0qAKSNc05dXV0Kh8MaNuzy98e5V3EmT29vr5qbm7Vq1aqU9crKSjU2Nvbb39PTo56eHu/5qVOnNH369AGfEwAGSnt7uyZMmHDZ6xmJ81tvvaXz588rGAymrAeDQcXj8X77Y7GYnnzyyX7r7e3tKiwsHLA5ASDdksmkJk6cqIKCgv+6LyNxvujdb0k45y75NkVtba2qq6u95xd/uMLCQuIMICu911uyGYnz2LFjlZOT0+8uuaOjo9/dtCT5/X75/f6rNR4AZFxGPq0xYsQIlZaWqr6+PmW9vr5eZWVlmRgJAEzJ2Nsa1dXVuu+++zRr1ix9/OMf17Zt23Ty5Ek99NBDmRoJAMzIWJzvuusu/fOf/9TatWt1+vRplZSU6Je//KUmT56cqZEAwIyMfc75g0gmkwoEAkokEvxCEEBWudJ+8bc1AMAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudYLKabbrpJBQUFGjdunBYsWKBjx46l7HHOac2aNQqHw8rLy1NFRYVaW1vTPQoAZK20x7mhoUHLli3Tn/70J9XX1+vcuXOqrKzU22+/7e3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjk3kN/gH//4h8aNG6eGhgbdcsstcs4pHA4rEolo5cqVkqSenh4Fg0Ft2LBBS5cufc/XTCaTCgQCSiQSKiwsHMjxASCtrrRfA/6ecyKRkCSNHj1aktTW1qZ4PK7Kykpvj9/vV3l5uRobGy/5Gj09PUomkykPABjMBjTOzjlVV1drzpw5KikpkSTF43FJUjAYTNkbDAa9a+8Wi8UUCAS8x8SJEwdybADIuAGN8/Lly/XKK6/oRz/6Ub9rPp8v5blzrt/aRbW1tUokEt6jvb19QOYFACtyB+qFH374YR04cECHDh3ShAkTvPVQKCTpwh30+PHjvfWOjo5+d9MX+f1++f3+gRoVAMxJ+52zc07Lly/Xvn379Nxzz6moqCjlelFRkUKhkOrr67213t5eNTQ0qKysLN3jAEBWSvud87Jly7R792797Gc/U0FBgfc+ciAQUF5ennw+nyKRiKLRqIqLi1VcXKxoNKr8/HwtWrQo3eMAQFZKe5y3bNkiSaqoqEhZ37Fjhx544AFJUk1Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCsNOCfcx4IfM4ZQLYy8zlnAMD7R5wBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGDQgMc5FovJ5/MpEol4a845rVmzRuFwWHl5eaqoqFBra+tAjwIAWWNA49zU1KRt27bp+uuvT1nfuHGjNm3apLq6OjU1NSkUCmnevHnq6uoayHEAIGsMWJzPnDmjxYsXa/v27brmmmu8deecNm/erNWrV2vhwoUqKSnRzp07dfbsWe3evXugxgGArDJgcV62bJnmz5+vW2+9NWW9ra1N8XhclZWV3prf71d5ebkaGxsv+Vo9PT1KJpMpDwAYzHIH4kX37NmjF198UU1NTf2uxeNxSVIwGExZDwaDOnHixCVfLxaL6cknn0z/oABgVNrvnNvb27VixQrt2rVLI0eOvOw+n8+X8tw512/totraWiUSCe/R3t6e1pkBwJq03zk3Nzero6NDpaWl3tr58+d16NAh1dXV6dixY5Iu3EGPHz/e29PR0dHvbvoiv98vv9+f7lEBwKy03znPnTtXR48eVUtLi/eYNWuWFi9erJaWFk2ZMkWhUEj19fXe1/T29qqhoUFlZWXpHgcAslLa75wLCgpUUlKSsjZq1CiNGTPGW49EIopGoyouLlZxcbGi0ajy8/O1aNGidI8DAFlpQH4h+F5qamrU3d2tqqoqdXZ2avbs2Tp48KAKCgoyMQ4AmONzzrlMD/F+JZNJBQIBJRIJFRYWZnocALhiV9ov/rYGABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYNCAxPnUqVO69957NWbMGOXn5+uGG25Qc3Ozd905pzVr1igcDisvL08VFRVqbW0diFEAICulPc6dnZ26+eabNXz4cP3qV7/Sa6+9pm9/+9v68Ic/7O3ZuHGjNm3apLq6OjU1NSkUCmnevHnq6upK9zgAkJV8zjmXzhdctWqV/vCHP+j555+/5HXnnMLhsCKRiFauXClJ6unpUTAY1IYNG7R06dL3/B7JZFKBQECJREKFhYXpHB8ABtSV9ivtd84HDhzQrFmzdMcdd2jcuHGaOXOmtm/f7l1va2tTPB5XZWWlt+b3+1VeXq7GxsZLvmZPT4+SyWTKAwAGs7TH+Y033tCWLVtUXFys3/zmN3rooYf0yCOP6Ac/+IEkKR6PS5KCwWDK1wWDQe/au8ViMQUCAe8xceLEdI8NAKakPc59fX268cYbFY1GNXPmTC1dulRf/OIXtWXLlpR9Pp8v5blzrt/aRbW1tUokEt6jvb093WMDgClpj/P48eM1ffr0lLVp06bp5MmTkqRQKCRJ/e6SOzo6+t1NX+T3+1VYWJjyAIDBLO1xvvnmm3Xs2LGUtePHj2vy5MmSpKKiIoVCIdXX13vXe3t71dDQoLKysnSPAwBZKTfdL/joo4+qrKxM0WhUd955p44cOaJt27Zp27Ztki68nRGJRBSNRlVcXKzi4mJFo1Hl5+dr0aJF6R4HALJS2uN80003af/+/aqtrdXatWtVVFSkzZs3a/Hixd6empoadXd3q6qqSp2dnZo9e7YOHjyogoKCdI8DAFkp7Z9zvhr4nDOAbJWxzzkDAD444gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIPSHudz587p8ccfV1FRkfLy8jRlyhStXbtWfX193h7nnNasWaNwOKy8vDxVVFSotbU13aMAQNZKe5w3bNigrVu3qq6uTn/5y1+0ceNGffOb39RTTz3l7dm4caM2bdqkuro6NTU1KRQKad68eerq6kr3OACQldIe5z/+8Y/63Oc+p/nz5+vaa6/V5z//eVVWVuqFF16QdOGuefPmzVq9erUWLlyokpIS7dy5U2fPntXu3bvTPQ4AZKW0x3nOnDl69tlndfz4cUnSyy+/rMOHD+u2226TJLW1tSkej6uystL7Gr/fr/LycjU2Nl7yNXt6epRMJlMeADCY5ab7BVeuXKlEIqGpU6cqJydH58+f17p163TPPfdIkuLxuCQpGAymfF0wGNSJEycu+ZqxWExPPvlkukcFALPSfue8d+9e7dq1S7t379aLL76onTt36lvf+pZ27tyZss/n86U8d871W7uotrZWiUTCe7S3t6d7bAAwJe13zo899phWrVqlu+++W5I0Y8YMnThxQrFYTEuWLFEoFJJ04Q56/Pjx3td1dHT0u5u+yO/3y+/3p3tUADAr7XfOZ8+e1bBhqS+bk5PjfZSuqKhIoVBI9fX13vXe3l41NDSorKws3eMAQFZK+53z7bffrnXr1mnSpEm67rrr9NJLL2nTpk168MEHJV14OyMSiSgajaq4uFjFxcWKRqPKz8/XokWL0j0OAGSltMf5qaee0te+9jVVVVWpo6ND4XBYS5cu1de//nVvT01Njbq7u1VVVaXOzk7Nnj1bBw8eVEFBQbrHAYCs5HPOuUwP8X4lk0kFAgElEgkVFhZmehwAuGJX2i/+tgYAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBg0PuO86FDh3T77bcrHA7L5/Pppz/9acp155zWrFmjcDisvLw8VVRUqLW1NWVPT0+PHn74YY0dO1ajRo3SZz/7Wf3973//QD8IAAwm7zvOb7/9tj760Y+qrq7uktc3btyoTZs2qa6uTk1NTQqFQpo3b566urq8PZFIRPv379eePXt0+PBhnTlzRp/5zGd0/vz5//0nAYDBxH0Aktz+/fu95319fS4UCrn169d7a++8844LBAJu69atzjnn/v3vf7vhw4e7PXv2eHtOnTrlhg0b5n79619f0fdNJBJOkkskEh9kfAC46q60X2l9z7mtrU3xeFyVlZXemt/vV3l5uRobGyVJzc3N+s9//pOyJxwOq6SkxNvzbj09PUomkykPABjM0hrneDwuSQoGgynrwWDQuxaPxzVixAhdc801l93zbrFYTIFAwHtMnDgxnWMDgDkD8mkNn8+X8tw512/t3f7bntraWiUSCe/R3t6etlkBwKK0xjkUCklSvzvgjo4O7246FAqpt7dXnZ2dl93zbn6/X4WFhSkPABjM0hrnoqIihUIh1dfXe2u9vb1qaGhQWVmZJKm0tFTDhw9P2XP69Gm9+uqr3h4AGOpy3+8XnDlzRq+//rr3vK2tTS0tLRo9erQmTZqkSCSiaDSq4uJiFRcXKxqNKj8/X4sWLZIkBQIBfeELX9CXv/xljRkzRqNHj9ZXvvIVzZgxQ7feemv6fjIAyGLvO84vvPCCPvnJT3rPq6urJUlLlizRM888o5qaGnV3d6uqqkqdnZ2aPXu2Dh48qIKCAu9rvvOd7yg3N1d33nmnuru7NXfuXD3zzDPKyclJw48EANnP55xzmR7i/UomkwoEAkokErz/DCCrXGm/+NsaAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEHEGQAMIs4AYBBxBgCDiDMAGEScAcAg4gwABhFnADCIOAOAQcQZAAwizgBgEHEGAIOIMwAYRJwBwCDiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwKDfTA/wvnHOSpGQymeFJAOD9uditix27nKyMc1dXlyRp4sSJGZ4EAP43XV1dCgQCl73uc++Vb4P6+vr05ptvyjmnSZMmqb29XYWFhZkeK2OSyaQmTpzIOXAOkjiHi6yeg3NOXV1dCofDGjbs8u8sZ+Wd87BhwzRhwgTvfw8KCwtNHX6mcA4XcA4XcA4XWDyH/3bHfBG/EAQAg4gzABiU1XH2+/164okn5Pf7Mz1KRnEOF3AOF3AOF2T7OWTlLwQBYLDL6jtnABisiDMAGEScAcAg4gwABmVtnJ9++mkVFRVp5MiRKi0t1fPPP5/pkQZULBbTTTfdpIKCAo0bN04LFizQsWPHUvY457RmzRqFw2Hl5eWpoqJCra2tGZr46ojFYvL5fIpEIt7aUDmHU6dO6d5779WYMWOUn5+vG264Qc3Nzd71oXAO586d0+OPP66ioiLl5eVpypQpWrt2rfr6+rw9WXsOLgvt2bPHDR8+3G3fvt299tprbsWKFW7UqFHuxIkTmR5twHzqU59yO3bscK+++qpraWlx8+fPd5MmTXJnzpzx9qxfv94VFBS4n/zkJ+7o0aPurrvucuPHj3fJZDKDkw+cI0eOuGuvvdZdf/31bsWKFd76UDiHf/3rX27y5MnugQcecH/+859dW1ub++1vf+tef/11b89QOIdvfOMbbsyYMe4Xv/iFa2trcz/+8Y/dhz70Ibd582ZvT7aeQ1bG+WMf+5h76KGHUtamTp3qVq1alaGJrr6Ojg4nyTU0NDjnnOvr63OhUMitX7/e2/POO++4QCDgtm7dmqkxB0xXV5crLi529fX1rry83IvzUDmHlStXujlz5lz2+lA5h/nz57sHH3wwZW3hwoXu3nvvdc5l9zlk3dsavb29am5uVmVlZcp6ZWWlGhsbMzTV1ZdIJCRJo0ePliS1tbUpHo+nnIvf71d5efmgPJdly5Zp/vz5uvXWW1PWh8o5HDhwQLNmzdIdd9yhcePGaebMmdq+fbt3faicw5w5c/Tss8/q+PHjkqSXX35Zhw8f1m233SYpu88h6/7w0VtvvaXz588rGAymrAeDQcXj8QxNdXU551RdXa05c+aopKREkryf/VLncuLEias+40Das2ePXnzxRTU1NfW7NlTO4Y033tCWLVtUXV2tr371qzpy5IgeeeQR+f1+3X///UPmHFauXKlEIqGpU6cqJydH58+f17p163TPPfdIyu5/D1kX54t8Pl/Kc+dcv7XBavny5XrllVd0+PDhftcG+7m0t7drxYoVOnjwoEaOHHnZfYP9HPr6+jRr1ixFo1FJ0syZM9Xa2qotW7bo/vvv9/YN9nPYu3evdu3apd27d+u6665TS0uLIpGIwuGwlixZ4u3LxnPIurc1xo4dq5ycnH53yR0dHf3+6zgYPfzwwzpw4IB+97vfacKECd56KBSSpEF/Ls3Nzero6FBpaalyc3OVm5urhoYGffe731Vubq73sw72cxg/frymT5+esjZt2jSdPHlS0tD59/DYY49p1apVuvvuuzVjxgzdd999evTRRxWLxSRl9zlkXZxHjBih0tJS1dfXp6zX19errKwsQ1MNPOecli9frn379um5555TUVFRyvWioiKFQqGUc+nt7VVDQ8OgOpe5c+fq6NGjamlp8R6zZs3S4sWL1dLSoilTpgyJc7j55pv7fZTy+PHjmjx5sqSh8+/h7Nmz/f5gfU5OjvdRuqw+hwz+MvJ/dvGjdN///vfda6+95iKRiBs1apT729/+lunRBsyXvvQlFwgE3O9//3t3+vRp73H27Flvz/r1610gEHD79u1zR48edffcc09WfGTog/r/n9Zwbmicw5EjR1xubq5bt26d++tf/+p++MMfuvz8fLdr1y5vz1A4hyVLlriPfOQj3kfp9u3b58aOHetqamq8Pdl6DlkZZ+ec+973vucmT57sRowY4W688UbvI2WDlaRLPnbs2OHt6evrc0888YQLhULO7/e7W265xR09ejRzQ18l747zUDmHn//8566kpMT5/X43depUt23btpTrQ+EcksmkW7FihZs0aZIbOXKkmzJlilu9erXr6enx9mTrOfAnQwHAoKx7zxkAhgLiDAAGEWcAMIg4A4BBxBkADCLOAGAQcQYAg4gzABhEnAHAIOIMAAYRZwAwiDgDgEH/B9l3Kld+JNUoAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 6 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([6])\n", - "inverted image 6\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 7\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 7 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([7])\n", - "inverted image 7\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 8\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 8 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([8])\n", - "inverted image 8\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWcAAAGhCAYAAAC9CXUkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACKNklEQVR4nO29efyVZbn9v1DhM6BxTvoVxNSwOGmpOaBoalDmgDgPqSnOiuIA4oCIA6KAoiEGKGLmhIDzmDMqDmWSQ9ro8WgdKzlkmaQgkO7fH7727ftamw91fgdjb7jW69WrS3j23s++n/t52Ne611p3u0qlUlEikUgk6gorLesTSCQSiUQt8uGcSCQSdYh8OCcSiUQdIh/OiUQiUYfIh3MikUjUIfLhnEgkEnWIfDgnEolEHSIfzolEIlGHyIdzIpFI1CHy4ZxIJBJ1iGX6cL7iiivUrVs3NTc3a4stttBTTz21LE8nkUgk6gbL7OF88803a9CgQRo2bJhefPFFbb/99urTp4/++7//e1mdUiKRSNQN2i2r4KOePXtq880315VXXln+bMMNN9Ree+2l0aNHL/G1H330kf74xz9qtdVWU7t27T7tU00kEomlhkqlor/97W/q2rWrVlqp7d/Hq/wLz6lg4cKFev7553XmmWeGP99pp530ox/9qOb4BQsWaMGCBeW///CHP+jLX/7yp36eiUQi8WnhzTff1Oc+97k2/36ZPJzffvttffjhh+rcuXP4886dO2v27Nk1x48ePVrnn39+zZ9fe+21am1t1cyZM8Of9+rVq9S/+tWvSv3mm2+G41pbW0vd0tJS6vfff7/U/sv8o48+Wuxrttxyy3Dcz3/+81L/+te/LnX//v3DcbNmzSr1//t//6/U7du3L/X//M//hNccdNBBpb777rtL3aFDh3Dcb3/721L/5S9/KfVnPvOZcNyaa6652L/jOEjSu+++W+rVV1+91Kus8sk0clpqm222Wez7zZkzJxy3xRZblJrdVL9+/cJxvIarrbZaqV977bVS85pL0rrrrlvqNdZYo9R//etfw3H8Hi+99FKpjzrqqHAcr1mPHj1K/dOf/jQc95//+Z+l3mijjUrNZtXn19prr13qZ599ttR+zfiL65133ik1r4skzZs3r9Rf/OIXS817z8fr85//fKmffPLJUvNaStJvfvObUnPuvv766+G4P/7xj6XeeeedS927d+9w3IQJE0p91llnlXrUqFGl5v0nSf/+7/9e6rfffrvU//Zv/xaO4/j94he/KPXWW28djuMYPfjgg6XebrvtSu33Ba8n5+Faa60Vjque0/z583XccceF+bs4LBNa449//KPWXntt/ehHPwoXfOTIkbrxxhvDw0yq/eU8d+5crbPOOtp7773Vvn378CCT4kBusMEG4XXEj3/841IfeOCBpb799ttL7ROXDxHezG+99VY4br311iv1qquuWmo+MCVpzz33LPXKK69c6rvuuqvUH3zwQXgNJ2SfPn1KPWPGjHBcU1NTqR966KFS+wNh0qRJpf79739f6nvvvTccxxvrD3/4Q6kXLVpU6ueffz68hjf6V7/61VLzBpGkTp06lXrhwoWlfvHFF8Nx3bt3L/Umm2xSan73P/3pT+E1HTt2LDX/4XZcf/31pf7CF75Q6m9/+9vhOI7fDTfcUOq99torHMcx4sNi/vz5pX788cfDa/iPPL8HfwhI0nPPPVfqk08+udROCXL+c8wHDx5c6r///e/hNXzI8XNvvfXWcNxWW21Vao6X4/777y/1f/zHf5T6b3/7WziuZ8+epeY8vPDCC0vtvzT5/Hj44YdLfdxxx4Xj3njjjVJzTvIekeI/iIcddlip+QPQ/xHm84ZzY+ONNw7HVe/pBQsW6Morr9S7775b848usUx+Oa+xxhpaeeWVa34lz5kzp+bXtPTxAPogJhKJxPKMZaLW6NChg7bYYgs98sgj4c8feeQRfe1rX1sWp5RIJBJ1hWXyy1n6uK3q16+fevTooW222UaTJ0/Wf//3f9e0I4lEIrEiYplJ6aSPTShjxozRW2+9pY022kiXXXaZvv71r//D182dO1edOnXS8OHD1dzcXMNdcQGI3Bw5XUnq27dvqcmtkZvjAo2koCY55phjSu2LIOS1aK4htypFvnb99dcvNSkfX+Qh7/a73/2u1M45f/azny31l770pVI7Z+bvX8Wf//zn8N9cmCSPzoUd59B4TuyKHn300XAcF0f222+/Ujv1RR6W7/HNb36z1Iccckh4zfjx40vNMfYFQYLfz+VO/G8uyG622WbhOC7QcsGMax/Nzc3hNeRGudjI7yBFrvW//uu/Sr377ruH47p06VJq8qlcBOYckiIX7POf4Pcgr88FUz8HjpHfM1xX4vvxEeXrL+SwuXjJ9SBJ2mOPPUrNNS2uW/i5PvPMM6XmveCLiJzj22+/falvu+22cFx1Xr///vvq27dvfXLOVQwYMEADBgxYlqeQSCQSdYnM1kgkEok6xDKlNf7/okprjBo1Ss3NzXrsscfC3++7776lZuvqUrpNN9201GztSH+wHZViK0YJEuVfUmwNncogvvGNbyz2/b7yla+U2iVtV111VanHjRtX6vvuuy8cR53mxIkTS/2Tn/wkHEc5Hr/fNddcE46jDI16YbaJlG5JkU6hbMxNRNTqsnWlpMpfR901W1pvxUkP8L29rb7kkktKfcQRR5SaLbEUabNXXnml1N4isxUmlUStbrdu3cJr7rnnnlKTliKFJkl33HHHYo9zqRnb5vPOO6/U3/nOd0r9wgsvhNeQFuK8cVCzTympK64oRyUV5eNFWoMS0yeeeKLUpAGlKEukfJV/LkVKjtSW5/mQluDzgvcmtdBSfMaQluLckKT33nuvvNeMGTP+Ia2Rv5wTiUSiDpEP50QikahDNDStceihh6pDhw7BzixFC2Vbdl8pKjRo5WZ75S0aHWu0KrMN8/fo2rVrqbm676+jzZWuR7dEb7jhhqVmu8zPkaJShfbhJTkOScess8464TiuoJOGYPvuVAHdU1zldmUJV8lpNaf9WIptO12PbO15blJshena4jX391iS65HW/KFDh5Z6+vTp4bgdd9yx1NWWVorXmX/u58e/+/DDD8NxpHtIvXmbTLUL5yTf28eBbkYqQdxuzbad9JXHJPAaUl3hdOSuu+662L+josUt5HRhks4i7ebfgzSLUw+ch1QN8fVOrdCmz3uT95Ukvfzyy5I+vg5jxoxJWiORSCQaEflwTiQSiTpEPpwTiUSiDtHQnPOMGTO06qqr6uqrrw5/T2nYL3/5y1JTYidF7o/vwbQtptBJ0SFIZ51zgpThkCdjFKUUOUbKwejgco6YnOrmm29eane8MbKQsjqmy0kxApHv4ZwZP5c85QMPPFDqgw8+OLyGfDm5SI9T5DrBSSedVGqmvkkx/YySR0qYmDAoxchJyuAovZKio48OM49ipYOUKWRLikvle/A4nzccB8osXe5GTpW8JZPdpCgR5XoJnXqca1L8flxDcLnokUce+Q/PW4prA5QOck1Einwv7x8+otydR2me3ycE72Ny7x7/yXuac4p8tjtsea533nlnqW+55ZZwXHX858+fr5NPPjk550QikWhE5MM5kUgk6hDLNFvj/4rp06erQ4cONaHWDHihY83dQAy3oUyMLjRvVffZZ59Sjx07ttSUqkkxxJtONm8hKd9iwP60adNK/fTTT4fXUFpEqsBpDf4d23Rnsjh+pD981wl+x7YoGG/T25JbueyPriuGq3vbyTaQ1AjpHXe18Xqy/aZzUIrUAVt4d91x/EkjUAIoRQccXZ1MXvQAe0qxKEHzDSUY9EQ3nFMFpF04D6dMmVJq3ySA15NSNc5VKTpNSTFddtll4ThSOvweHgxESoySO1IrLr/jbix01fqGCzwH7sLjIU0EJYqUlfouK3SQ8t7iPSx9IuVdEv1C5C/nRCKRqEPkwzmRSCTqEA1NayxatEjt2rWrCRbiijBbTaozpNi6cpWWATGkPqTYLnGPMc+K/sEPflBqtpBUIkjSpZdeWmq2WwwT8sAmtr7cc475s1Jsi3ne3iLT2cbXeM4znXEEM7hdhcFWmOPt40rHGvewGzlyZDiO+z5WHVdS3AjWw6pI97D19f0cScmwjWVr72Ab6wFV/B4cB1JCbMsl6dBDDy01VQVUHUnRIUiVg89x0kekU/i5TjGRzqLaw9VOVDPQQec0ECknuknpwJMiTcLPZVCRUwr8LM4vP47jxXFl0JEU9zskLUV3sStG6Pql+9Cpzip96K7XtpC/nBOJRKIOkQ/nRCKRqEM0NK2x/fbbq7W1NRhDJGmnnXYqNVs2tjNSDIVh63rxxReXmvm6fhzbRBfes70njeAmFLbFzGameuRb3/pWeA1XuUmZuLmErSHbMqeBuKUWv58rS7jyT6MPaSC2sFJUFZC28QCotlbGaXCRYq4uV8lvuummUu+yyy5tvje3uPfV9MGDB5eaRgMPBiL9wdV+NxRw/KnyueCCC0rtOwFNnTq11AcccECpfQssKhhIB7hxiDQQ5yHzjR00G5Ei9NeQbiBt4FtEMUyL9JVv5swAIZ4DKTmnYHgOpJGoTJHitaFawrdBI2Xx1a9+tdRUZjl1x/uJIWw/+9nPwnFVqsVpxbaQv5wTiUSiDpEP50QikahD5MM5kUgk6hANzTkvWrRICxcurJGs3H777aWmO8ylYZTbUFJDPo9BOVKU5jEs6YorrgjH0XVHxxR5MSnyheTCGLTibifyinRSudyKnDEdiz/84Q/DceQSybM558zPpXOSkqNtt902vIbBRQyfd8kX+UfyjeQUpSjnY0APnYQMn5Gk3XffvdR0jHIfPUnaYYcdSs2AfXd0UcrI4HVeCyny4+RTyfHTFSrFYCfy/84lc43j3HPPLbW7P1da6ZPfX5z/vC98LYbSQ8r0GDLk58D1CDpBpSgv43z3/SZ5relU5RqCuwr5GkrzuG4kRa6aEkB/dlBGSIft3nvvXWo6RKXoSKab153L1XvG9zdsC/nLOZFIJOoQ+XBOJBKJOkRD0xpz5sxRc3NzTctH2RFbNrqYpNiesF2mJM1DYSgLYnvkew1SykPJFtsjKbZVbGNJrXDbeSnSEGxjd9ttt3AcW30GxlAeJUVpD+kFlyjy+9KZxRaZ7jcpSu7YFlNmJkVJE8eE1IUU5XiUyDGDmzJEKdISlL558BHnB1/j7SmvE2kIUgBSlE3SkcdW3PfbIz1AasvnONtv0gMud+Mc57iQbvLMcrr4SFP5OVAyx9f4OFAaSanatddeG46jZJESQ9J6nsHN78u55w5BylHpAuT9LMWxvP7660vNe9CfCbyfKJns27dvOO6UU06RlMFHiUQi0dDIh3MikUjUIRp6m6oxY8aopaWlRlFx3333lZrttzt72NJ079691Gz56AKUYjvJ1smVEmztmGnsag226fvvv3+p6S5yxxVpBLZb3soxYIUto6s/OAX4d3RzSVLv3r0X+35UsPiW9FQzkBbx46677rpSs911lxWvGcfuiSeeKLWrMDgu3KrJs6fZmnNMXIVBtQYDqjzvmEFUbJepmnAHJNUVpAPcgUpaiJScjytpF7oFGZjlQTycb1Q5uCKJ9x3pMH4HKWZW8zv5fcsgK94nHH9XXLVFrbjKZ8KECaWmeur73/9+OO6YY44pNUPJ+LlOtfE1VKP4OVTvrQULFmjMmDG5TVUikUg0IvLhnEgkEnWIfDgnEolEHaKhOefvfOc76tChQ+DVpCgfItfnnCDdPJTcUQLj8ju6ncgze2oYuUjy3u6KohSI/DFdd76PISVRTIHjFvRSlNJxG3uXyPHced4uD2wr+Y0B9r5PI8eYaYEMRpcif0yHmk9Pcn/k9Hiuzr2Tv7z88stLTTekFF2UlMs558z9Dil55Hfw78G/4zg438vP5bXg9ZPimsbpp59eavKf/v78ftxr8Oijjw6vueaaa0q9zTbblJrX3/+O6znuoOOcp5uOSYmS1KtXr1JPmjSp1HTvurOU6yKcxy65o4yT6yC+gQQld3SaUiLnc5fPCEplq9K5KqrX/YMPPtCIESOSc04kEolGRD6cE4lEog7R0LTGVVddpZaWlhrHDffco3yLUjApyn+4jx4pDm/t2cLzOG9PKS9j7YH4DNih5Ih0hdMxbJEZ1uMSJlIMlE65hInyMrra2AZLsb2kBIxj8vjjj4fXcH9BfiffF5FUzY033lhqtuxSbIv5nSZOnFhqd6hRdka6aNdddw3HUbbHtvh73/teOI7XkNSF00p+ratga86xk6SWlpZS05FHV5sU9z8kDXHCCSeE49g287pT0kYnnCRtuummpeb88mtGSoHUG18jRUfckCFDSu1t/6uvvlpqOhMpkeNc9XPia1zuRiqKwUNOiXIfSH4ux5UbIkjxOUKXolOi1Y0nPvjgA5111llJayQSiUQjIh/OiUQiUYdoaFqjb9++at++vc4///zw93RmsYVxpx1X++n6ohPqkEMOCa/hijVdcoMGDQrHDRw4sNR09HlGMgOSXnvttcWej7dybLHYhnG/Pkn6wQ9+UGq22E5XcNWde/u5g440CV14M2bMKLVPJ65eU7nh7im22WzZ2epKsTUnBUNaybeu5xxgprS7NenkZPiSt/O87swdZm60FDOcOZZUM/h7k5oibeDzhmNJ6ufUU08Nx51zzjml5n1BJU+HDh3Ca/hZ/A5UU0gxd5vz2B2oVCFxrjHvWorqDV4zUkeuxCE493jeUgwF43u48oLXg2osXgvSbpJ05plnLvY4pyyqFMp7772nXr16Ja2RSCQSjYh8OCcSiUQdIh/OiUQiUYdo6LD9ww8/XK2trYGjlKKLj24s5xjJA9INRBnVqquuGl7DgHdKhsgBSlL//v0X+x4uNSN/SScaeTZKdaTouGJYO4PaJalfv36lfuSRR0p90EEHheOYwkfJFsdOkk4++eTFfi4T0ygblGLIPx155Cil6FijRNH3JHz44YcX+3cMs3cekdI1uu6YZCdFd93o0aNL7eNAvpbrCb6mQWke34NSLIbKS3FNg7I651rJ+XO83PVIPpmpbwcffHCpPVGRLkzyxeT4pbgZAJ2NziXvu+++pea14V6fUlwP4PU8/PDDS+0yNl4LSgBdLsr7jvPG9xC88sorS815zXnj7811ET4fuIYkfSI3zLD9RCKRaGDkwzmRSCTqEA1Na6yyyipq3759aIGk2LLRdedoq3078MADS83gfilKnUgBOPXAloYuRQ/HoTzp85//fKlJk7hLkRI5OsyGDx8ejmM4EeVRLpHje7DlouxJihIp0hd8/Ze+9KXwGrr1SF1QKijF0BpKGV3mxc0OeN1JMU2ZMkVtgRSAh1DR3cXrSZmfFK8h2+LbbrstHMfvSLcYaTPf8497KdIB6a0w22fOL9+cgJtIUGpJyZhLK+lIJbXiew0yTIih/H4vUG7I+4IhQ1K8NpxrV199dakZIibFvSNJZ/q8oQyU9JPvz8m5TKqGNKPTgjxXjpFvpFCV2fF7Lgn5yzmRSCTqEPlwTiQSiTpEQ9Mab7/9tubNmxdWaaXYPnNF2SkFrrKy5WOb5206XWAjRowotSsEGKjC8B+umDu4Csx8XO5LJkmHHXZYqakycWccV7nbt29farbOktSpU6dSsx30wCW2zHRjMdOYtRRDh9iS/v73vw/HUWXAdnfmzJnhOLaEffr0KTUDpJwyoVqGq+6ugOB3Z5vuLTIdm9zTkOFNUmx36QpknvDNN98cXkPKg3SK0x+c44RTBTwHhgGdffbZpSadI8Xx4ndnmy/Fe4Hv4edK5yUVMU4pMDyJKhh+p/POOy+8hq5HUj2uXOJc5r1K1ZG/jlQglRuzZs0KryFNyHuV6hPpkz0cU62RSCQSDYx8OCcSiUQdoqFpjZVWWkkrrbRSjbGD7RGDd1hLUd1AMwjDS3wlmyEnbJ99lZyUSVtqCCmutFOtwT9nSyXFVWAaayj2l2IbO3ny5FK7SoGUAttvZidLUXFAmoQto2+BRTUDP8cF+vy+/FwaaaRo7iGdRfqEVJZ/FsfIqRXOIwbvOGXFkCVmLvu40uTC+cXQp+222y68ht+DtQdK0bBEkw2viyT99Kc/LTVpCJpd3JzFdp7UD6k2Kd5npBQ8V3zcuHGlJsXhx/E9OA9JWe23337hNRxjjhfzm6VooKKRiRSTFCkZjjkpOVcDkT4kRehKserzws1KbSF/OScSiUQdIh/OiUQiUYfIh3MikUjUIRqac1577bXVsWPHwNVKUSpGiY/LZk477bRSM0Cb7+c8Ih1T5OYYPC5FmRfDWpzD3njjjUtN2RNlcZQLSVFGxX3Y7rnnnnAc+VrKkZzr49535NncEUbHGuVW5Nu5T6B/D46xc4fknJfk0CTXSpciXVvu1CNnycAgug0lqWfPnqX+4Q9/WOpu3bqF47iRAvee9MAfcvHcv5Kf69w7JWTkUFdeeeVw3LRp00pNntPlogcccMBiP5euUw8O4z6LPAfyxVLka1m7NI+B/5SBck9KKXLTdDbSzfjzn/88vIZBReTR3dXJgCQ6X+kSluKaEGWqlP35azgnGSLla0VVl+IycwiOHj1aW265pVZbbTWtueaa2muvvWrs1ZVKRcOHD1fXrl3V0tKi3r1712zImEgkEisylvrDeebMmTrhhBP07LPP6pFHHtHf//537bTTTuFfrjFjxmjs2LGaMGGCZs2apS5dumjHHXcMgv5EIpFYkfGp7yH4pz/9SWuuuaZmzpypr3/966pUKuratasGDRpUtklfsGCBOnfurIsvvjhIpdpCdQ/BBx54QB07dqz5Zc79w7hHF2VPUpTCsQVla+PtJKVipAomTpwYjmurNWfAT/W7VMFWjHIddxqxdWWL5BIyZinTWXXHHXeE49jmkTJx+oMSMp4rpVw+xmxDKaXjfnFSdMZRysjAGSlKp0grcYw9mIYOTVIrdAFK0aFJZ5zTYZwrlEX5foD8b7bC119/famdkuOcouTOb1NK80gJuayU34M/fkjvUG4nxXuGY+T78vG6k9bjHpdSzBIn6KKVIh1JJy2diZTESZHaogxur732Csddd911peb19D38eO6kwzjG/kzguJDOdAdklbZcsGCBLrroomW/h2A1VL06od944w3Nnj07hI83NTWpV69eNRrZKhYsWKC5c+eG/yUSicTyjE/14VypVDR48GBtt912xYxQ/dfRYzA7d+5ck/lQxejRo9WpU6fyPyf7E4lEYnnDp6rWOPHEE/Xyyy/XbOEk1QaTVCqVmj+rYujQoRo8eHD577lz52qdddYpPLarGdZYY41ScyXbA3F4XqQH2Gr4OdFNxZXsP//5z+E4rqbTmUWqQYotPGkErrKTTpBiO8jPZbssRUckHW977LFHOI5OL7rm3CF47rnnlppdDttvd0CSxmEbzFqKrS8deU7VUBFBZQizqy+55JLwGlIofD8fhxkzZpSa4+DOOKoeeA50j0q1FFYVpE+OOOKI8He8TqSYmFUsxUAuzhtSOFJUWFAJwtbcXYqc8+xSXQ3EsDCqMHw7K855dsxUQ0jSt7/97VLzXiWF49ug3X333aVmpjfvTSkqJ+h6pEJKirQQaQnSda7MosqnGm4k1aqdqi5Dv5/bwqf2cD7ppJN0zz336MknnwzWx2r4+uzZs8OknzNnTs2v6SqamppqJGiJRCKxPGOp0xqVSkUnnnii7rjjDj322GM1GtFu3bqpS5cuNb+UZs6cWbODQiKRSKyoWOq/nE844QRNnTpVd999t1ZbbbXCI3fq1EktLS1q166dBg0apFGjRql79+7q3r27Ro0apdbW1rCCnEgkEisylrqUri3e+Nprry3pTZVKReeff76uuuoqvfPOO+rZs6cmTpxYs015W6hK6Z588kmtuuqqNVInyn8YZu58KH+pkzsk7+cSOUqfyH9SCibFVCymbbmMjbwknVrk3DwFi4ld5MLoqpIid3vBBReUeuTIkeE4StLIu7o7kq5AJuPtv//+pXZekjI9hpJ7ahinIflsfqYU+XHSYtzu3heWeW3o/HOp06677lpqhvJ791dVIEnReebUGxeu6aBjcpy7FCnNI7fJREApSuTItbqslHOAcjCuE/h50xDGz/FxIP/LNRs/jlI4jp27GTkP6brjnPKNNShR5Dk4N811JJ6Pu/V4Djw/PlP8kUnOmefq6XPVdMp58+bpmGOO+YdSuqX+y/mfeda3a9dOw4cPr9mQNJFIJBIfI4OPEolEog7R0MFHb7zxhlpbW2skctzHi24utkpSpGAoqeFxLk2aMGFCqXfbbbdSs333c2C4jS96Uk7UFiXk+8IxLIltuofCk0ZgWI+3UmytSQ94yAxbQEqnSAH4fntU6lCGOGnSpHAcW2HK3SiFlGJ7T8chZX8eov/oo4+WmmE7Ph9IU/F8qoE1VVCCR8mkt/OkC7j5AukYBuVIcR9Cno9Tctw04K677io1ZWf+31WllBTDro466qjwGs4P3lt+bUnpED7+/FxSby4PfPDBB0vNkC2eg1OfVHjx/LjPoxTdg7169Sq1R0ZQZke6lHJdpyt4P1La6tRd1fW4zIKPEolEIvF/Rz6cE4lEog7xqQcffRqoqjWOP/54NTU1acSIEeHv6WRjC+GOHa70MuSELfIVV1wRXvP666+XmsoB3zaelALbRCotpNj63H///aWm4qBv377hNdwDjVSBX8qdd9651Gzh2T5KUfHBz+UqtBTbOa5eMzjHFR5sXelEc1rj1FNPLTW/k7enVBnQzUXnmYcl0U3HMXZ6py21kLfvdHWyTXdHJakI0lkMb/KQIFJE3HvSFTZ8b6qLqJyRpPHjx5f66KOPLjWpLN//kiqFAQMGlNpdsN///vdLzaAhH3++H+eHK1VI//HeIrVIekKKVAadoB7ARaqM948HcPEe4r1AFYc7Rnk/Uc1FilD6hGJ6//331adPn2UffJRIJBKJ/z3y4ZxIJBJ1iHw4JxKJRB2ioaV0G264oVpaWoJMTIr8Fx1TLkcid0QJDblROgz97+hCYhKeFHlT8l/OyZJ3I49Lnpk8pBRTrcgLu5uOfDalfb63GZO0KHvyc+VYMBmPXKHLAenOo+ONezFKMQz9pJNOKrV/d0rP6BZjOLtLCul6JP/se+eR22SqGeWKkjRo0KBSjxkzZrHnLUU+lFkylGBedNFF4TUMayfvyvOWIrfMNELyz35O5Mo5V3y8eP9wXz8/B85RyggpXZQir0t3pHPTTLOjvI88MLlfKa71MPSeezZK0Q3KdD7ODUkh/ZJ7f9LlS1mkFFMnOV9dilqdD36N2kL+ck4kEok6RD6cE4lEog7R0LTG008/rQ4dOiwxRGfWrFmlZriRFFtNOvzYzn/3u98Nr6GDiy2ay4woqSF9QgpBiq00w3HoSPK2kyHnlAP6OZBiYBvL7eSlSLuceOKJpWbYu38WnWdsaV0+RJndvffeW2qnAChx4xi5PG3y5MmlJpVBmZ/TMWxJOTdcpkfaiw46l7txTpG68A0EKN+is5Hz1V2FHC/OtWuvvTYcRxqO8k7+uRTpIrrueJyPA8eSSZG+dx4lhldddVWpKSOVotORNITvIUi6h3Qk6Rjfx5B7CpIqc6fk7bffXmpSI5QrStFtSWqEc9KdpdzsgGPn16J6Pf/ZsP385ZxIJBJ1iHw4JxKJRB2ioWmNXXfdVa2trTVbuzMPmKEkvtLLlX+uzvM4tvJSbKtIV7j7kHnHXB0m3SHF9o3vxxbZg1KoBCFd4WoNtt/cn81VCmzTZs6cWWp3T9Gdx8CfJa1k83PpzOLrJalHjx6lZpu44447huMYQkTqgSoTD6ui+5NUj38//h3pD6eLqFJga++0Bs+JVAYdgu4Q4zyiQ23o0KHhOKoC9ttvv1K7646uR+Y+c//MIUOGhNfwu/O+cLqC9wbHzpVLvB433XTTYs9biuNH1QrVH6644jnQqefHkYJk+JUHH/GeYYATFU6kkaQ4BzhGnildzbL2c2sL+cs5kUgk6hD5cE4kEok6REPTGm+99Zaam5tDyyJFM0dbK8VSDIKhKoAqAGa/SrHl7t+/f6lHjRoVjqPCgq2hb8VOU8sLL7xQatIfrj7gdvcUtPtWRm1tK+WryBwvCuc9PIY0EHOW+XoaUqTYPtOQQsWJFLd04th5a0gKhVQBx47bMUmxzWbIjxtm2MZy/N18QeMJjSJ+rtz2itfmiCOOKDXNQVIc46233rrU3DpKkg4++OBSU3Xk+dBUjDDEi2YLKhmkSPdw7pEilKT77ruv1FSd+LZXnFOkK+bOnRuO4/hzuyd+J79/eN232mqrxZ63FFU1nNfcJk6KGeG33HJLqdvaukuSjjnmmFJzSzmnTKqKsFRrJBKJRAMjH86JRCJRh8iHcyKRSNQhGppzrsID7BkyT2mMS9KmT59eanKolLQ5b8Rwln79+pXaA9nJ9VHq57w3X8cAFYbt+F5r5GTJp7pEhw4zuv022WSTcBy/Ix1TlPlJMRCH3B85Xu7Z6KBDjQHsfq7kKMkBSpG/59iRR1zSGgS/k3PT5MTJf7qDjs42Hrckadjhhx9e6iXx3lwnePLJJ0vtMlB+LjlQzjsp8rC8TygvdK6cgVKUOPJ+keJ6B92tVclYFeSged4MwpLiWgqvO6+nuwo5Byh5/MEPfhCO23PPPUvNdSOOsRTnHj+Laydc95BieBL5er/Xqxsz+DOlLeQv50QikahD5MM5kUgk6hANTWusttpqamlpqQmPYZvHvdu8zSBFQVchXW2eO8yt2NlSedAKWzG2hnQnSXFPNAYSkV7g1vBSbL3Y7rJ9l6KTiW2d7xlHqRjbN2+56cijs410BYOJpBgew0xdd93dfffdpaYbi+cjRQkZ23TSUh5WxTb7sMMOK/W6664bjuP5cYw9zIm0F+cXHX1SlAcyEIcuUwZuSXFOMavbqRXOV1JJdHFKkfbi9eT4+xxnCBXvJacFKQ9kKBIpKinK1Tjfvb3nuJJ64Nx1GRqljG+++WapDznkkHAcnxF0aLr0k25G0hWUEboLlufKeeNO1SrN5RRoW8hfzolEIlGHyIdzIpFI1CHaVZhy0iCYO3euOnXqpGnTpqm1tbWm/aa6ga2Xt/1cHWbuLd2CbLel2BqylTv00EPDcVyVpjLBW2m2WKRM6J5y9QHbwZ122qnU3qKxheR3ZW6ufxbpGbbVUnSzMWOXn+MtG1fkSSn4ubJVZKvPoCMpKlp4LZh37G0ns4a51RbVGVKkNUiFOFVA9yCpMqe2eBxVQ6SsPHSI85BttSsq2EpTpcP5IMXxJ/3BECpSLlKkjqi0cHcex5nUGL+rFCmYvffeu9TuZuTc4RhRNeGuQqot+N6uXOI48L5dElXD60kaaMCAAeE1dDOSWnF6p0p7LViwQBMnTtS7775bE3xF5C/nRCKRqEPkwzmRSCTqEPlwTiQSiTpEQ0vp3nrrLbW0tNQ4dsjHkWfeZZddwnFMyKKjiDyiuw8JyuI8EY5cHXlT5znJhVH6xlQtDy+nG44cnO+HxrB38qnkiKUoi6PTy6WH/I5MlSOPTmmTFIP8mRDonCDlUnQBkv+UIr/317/+tdQHHHBAqd3JRr6Q/Ko72ZgiRw7bx4ESOcrnPO2PfCi/L3lJ5y/JM3OMXaJIeSW5WjoC/bM4/nSyuauTGyFwbnBNRIrzkNeFUkgpcq+UPPq9xc/ieE2aNKnU3NNQijLH2267rdRMnJRi0iTXS3zto+rik+K4kKf2PTjpnOUYnXPOOeG4008/XVKm0iUSiURDIx/OiUQiUYdoaFqjtbVVLS0tNY43tnyPP/54qd1lxRZw7NixpeZea5tvvnmbr3nmmWdK7VInyqjoOPQQI7Z8dDExwIbOKSm2g221zlJs9UmfuHqS7TzlaXQ7STHIp609EhmoI8U2kaHuHmDDzQo45nTTSXFzgrZCgrjHn1TrRqzCZY2UClJG5c4/trv8HqTTpLj/ISkYUj1+Le66665Sc59A3/iA4V6kQhg+L8U5QbcfZZIe/sM2/Y477ii1y754bzHYyfcx5HWiG9FpEt5DpPVY83ykSPmRGiPNIsVryOvi9y0pB9JrvLZOo5IaIc04bty4cFxVluvyvbaQv5wTiUSiDpEP50QikahDNLRDcOTIkWpubg6r51LMO6bCwNUMbQUIcd/AESNGhNewxWK75pQJ34M0Cx2BUnTDsb0kvfC5z30uvIbtOBUZ7rjiNvRsg91lxXNguJE7vS699NJS33rrraVmjjFzo6Wo/qCLjJSQFF143O7e23S6IxnQw4Clk08+ObyG+7pRqeJ7wTFDmPSTq2VIK/E1pC6kmMlNKoSqHA/totKBChsPCeLfca74OZAeO+igg0pNFYerd0in8L19HOgQ5Pm5SoFKky222KLUdOJKkU4kncX7lIoTKapvqL7i95Okxx57rNRUcLmjktnrpOt4nZzmIr1D+tCDj6rPmHnz5qlfv37pEEwkEolGRD6cE4lEog6RD+dEIpGoQzS0lG6VVVbRKqusEjg8KfKwlL24M4cpW5T4kIM75ZRTwmu47xwlQ+SnpChvIjfn8iHuacfzJv9Gh5QUHWFMWfNUNJ4r+UJ+jhS/L/lscvdS5O343SkHZBqfFGVx5BgpU5IiR0+pEaVzUuRUGYBOftdT/Ch/XNIedvzciy++uNQTJ04Mx1Ge9tvf/rbUl19+eTju3HPPLTUld9dff32pXZb1yCOPlHqjjTYqtUsw6TSl1HLgwIHhuH333bfUvM50ybms8Ytf/GKpyW1/+OGH4TiuG/BauASTvDzlmC5T5fzlPpdcE3E++9RTTy01eeol7YtIZyjXLaS4HsNNMvjn7iw98MADS33vvfeW2lPpqveMSw3bQv5yTiQSiTpEPpwTiUSiDtHQtMZf//pXNTc3h9ZSivIatlSUvEjR2cN9zth6uTyNrT5fsyTKhPvMOaVARxjb2LPOOqvU++yzT3gN23S2p05r9O/fv9RjxoxZ7OdIUfLDdtAlaWyfzz777FLTjeXBTpRikaJwWRavIWt33bG97NevX6lJHbkj8Iorrig1w/rdWUo53gUXXFBqhlhJsa2lnNIphR//+Mel5oYLbJddTsa5SxqBjlNJevvtt0tNadjMmTPDcaQlbrnlllIzBMzpCr6GckoPKiL9wfN2NyNlppTC+efyGu6xxx6LfY0HO3Hu7b///qVmUJEUryHpOaeV+H0p46T7kHShJD366KOl5phQlid98p1cwtkW8pdzIpFI1CHy4ZxIJBJ1iIamNbbaait17NgxtJZSbH1JN/gqPvNyudpMCsDbySOPPLLUzC6mWkCKVARbJw8GYq4u23k6ktwVxXaLNMLTTz8djuMqPJ1nbgrluVMJ4t+Jr+PW89wjjqE+UlxBp7PKW0NSSWyfSQFIcSyZDUznpV8znhM/h4FUUmzHeQ6+6k4HHR1erqhgq892nE5Qp0z4fUm7OW1GeoZOUHd/kkYj7UKKw6k25lKz5thJcU/IqVOnltrvR1IUpPucZuQYcc4/+OCDpXbKhFQb7yVSM1K8TpwfVIX4uVO9wwxnPjekSL3xc+iIlT65TzygrC3kL+dEIpGoQ+TDOZFIJOoQ+XBOJBKJOkRDc87Tpk1Thw4dQiqaFCVM5CVdhnPfffeVmpI5ckVHHHFEeM2NN95YanK6Lt156aWXSs1kNk8hI5f4rW99q9SUazGlTYoyKnJzfg58D3J9TAbz96cMzYPu+T3I3zNxzV9DFx65TedGt9xyy8W+n8ut+N9Dhgwp9bBhw0rt0kpywZRbcRylGLa/pHB1ukkp/+L1kyKvTk6cvL6nzfEcyBFzj0spXmuOnSc0cl5Ttsc5wNdLcbwos/RExbbejxsxSHGMTjzxxFLTtSdFGSevIe8R7tvp50q5oq/tkGeme9e5fK4vcI5SeuguWMpZubkE7znpk4TA+fPn659B/nJOJBKJOkQ+nBOJRKIO0dC0xtZbb62WlpYaORJbX7auvsX9scceW2pSAKRFPESfgUQM9GaouRTdazfccEOpnVqhdIoyIZ4Dw12kGMbE1pnuJCk6oSilY1stRdkRZV5s0aQYVsQWnkE+Rx11VHgNx4jSMEoXpUh5sO3jlvZSpKnYdvJc3XVHKoltMDdBkOI15LXwNpRzit+PTjEp0jO8TpTpbb311uE1vDacN04DcX5wowIPq+KcYAvPAKlrr702vIY0DuVpnENSpLZIuzgVSNqMlIe3/QwEInVEyZ0HYVG6RqrH6R1+LseLc1KK0kHem6RAXUpH2oahT+7ErdIfTqW0hU/9l/Po0aPVrl07DRo0qPxZpVLR8OHD1bVrV7W0tKh37976xS9+8WmfSiKRSDQMPtWH86xZszR58uQaofeYMWM0duxYTZgwQbNmzVKXLl2044471iyOJBKJxIqKT43WeO+993TwwQfr6quv1oUXXlj+vFKpaNy4cRo2bFhx0V1//fXq3Lmzpk6dGsJ6/hF+85vfqEOHDjVOI4JtD51dUmxpTj/99FLvvffepfb9wh5++OFSs93dddddw3FUPXDF24NpSLUwDIgtHkNXpNgOMuzIXXdsmeni+853vhOOo6KCITq+Ks0QKdIQDEiiSkWKq9/MvGZeshSzfbmK7+5IhhPxH3Oeq4cq8XOpCOB3leKqO+eNt6fjx48v9eGHH15qZjFLUcFA5xmvn9NmdN1RcUCljCTtuOOOpSY94+PKDOfddtut1FRxeMY4KQVSBe78o3qD95Y7SzkO/KHmmd78LFI/pKz8NbzWpPE8pIlO2r322qvUPr94v0+fPr3U7Pw9MItzl3uW+t6MVWpqmas1TjjhBPXt23ex8qLZs2eHjRWbmprUq1ev8AAhFixYoLlz54b/JRKJxPKMT+WX8/Tp0/XCCy/U7N4sffIvk/9r3blz55p/FasYPXq0zj///KV/oolEIlGnWOoP5zfffFMDBw7Uww8/XNNaEMz5lT6mO/zPqhg6dKgGDx5c/nvu3LlaZ511tNlmm6mlpaUmkIUtN00jJ5xwQjiOK7htqRQYfiJJX/nKV0r9uc99rtS+Us+VXrZHvsUNzRNcgeeKuee/0jTA77DBBhuE47gqTBE+x0SKAntSAL6dDltSbg3G8BnPUuYWQwx88ZV/KkYYGOSmA4ZNsU3nP+y+dkHaZtttty01r58UFQdUZPg4HHDAAaW+7bbbSu0tMvN8+XccL299aUIhjeCBP2uuuWapSY14UBTHgjQe5/H3vve98BoadaZMmbLYz5QilUeli6uieA/xHHidpbYVGrwWpBekmL/MMChX7JCaYofu28txHlFxxe9+9913h9f06dOn1FQTecBR9dqQPlsSlvrD+fnnn9ecOXMCz/Thhx/qySef1IQJE8qeebNnzw6TdM6cOTW/pqtoamqqkcslEonE8oylzjnvsMMOeuWVV/TSSy+V//Xo0UMHH3ywXnrpJa2//vrq0qVLWDxZuHChZs6cGXYMSSQSiRUZS/2X82qrrVazut2xY0etvvrq5c8HDRqkUaNGqXv37urevbtGjRql1tbWGhVBIpFIrKhYJg7BM844Q/Pnz9eAAQP0zjvvqGfPnnr44YeDG+mfwbx581SpVGrcQOQYqRZxNxAXGbmNPXlNDyoiR8jzJbcqRQkZeVPnL6dNm1Zqcm6kcVwiR26ZbiW6vqTIdfMfTA/yITdKPptBMlKUADHwnzwuHZRS5OLpKCNvK0WXFeWBzh+Th6V0iq+nDE6K+zE+88wzpaaby9+bvKTvY8h1A/6g4H52UhxLOv/ooDvmmGPCa8i9c63BN0ggb8nr59w013EodyPfO3bs2PAaBvGTanR+nG5EHudrGm2F7btD8Iwzzljse/uPPYIcPddsfP9L3o+8B13+yHGhMY5STV8H4Xvz+vl6VfX++WeldP+Sh7OnWbVr107Dhw/X8OHD/xUfn0gkEg2HDD5KJBKJOkRDBx+99957+vvf/17jCKOEjC0pA0+kKPlhJjRbZG9N2G5RwuRuM4ItrVMrbTnMSFF4SBDbakp8PEuZEsPjjjuu1Pfee284jmEvlHy5HInyOWZekypg2I/U9t5tTz31VDiO35eSR++66PSibI+vd0claSruJ+jtPPcUZAvvVBTlW6QbevXqFY5joBAdfqNHjy41Q6MkBYcsaRsPzOI8pCzOXbCkP0iH8Tq7xHTfffctNa+fzy/KxngvOM1IVRYdsuuuu244bsKECYv9O1IK/v0o+xs5cmSpXV7L13G+Ox252WablZpOR85rD+Oi1K9nz56lvuKKK8JxVcov9xBMJBKJBkY+nBOJRKIO0a7iy8ANgLlz56pTp046/PDD1aFDh5q84xEjRpSa7bebXKgEYLvrVAbB1p4hOmzx/L+ZL+30x6233lrqiRMnlnrMmDGlHjp0aHgNW0MGrTAUSIp0A9tEpxSoDKFbkKvQ/lmkFEiteK41nV5s56677rpw3KWXXlpqhkuxxZZUTExSVH/wvP37MbDpueeeK7UH+fDcqdbge0vSQw89VGpSY56nzTEnVUZFgLsKqXSoBoNJsd2W4oo/r4u7HtuiBEj9UGEgxaAu0gPu/iRdx2vrbT/VQXTvspbi9aTiinnQrpx55ZVXSk3jmwdKcZzb2pZNijQV348hYnQTS/E5wnFwx241+3v+/Pnq37+/3n333RplEZG/nBOJRKIOkQ/nRCKRqEPkwzmRSCTqEA0tpfvc5z6n5ubmmvBrSmXIK7pshsHwdFktiUOla4tcrctjKBvj57jbjy5Fup2YLuapYXxvcmnusOT+duTZ3HHFc+Iee3QYSpGzp4SJEkXutSZFlyHdg+Q1pRgsv6SAd5f3VUEp3UEHHRT+btKkSYt9b3cz0rFGTpf8pxQD2ZlLTj5cihI3fi7nmi/59O3bt9RM7nMnGyVyrMnbSpFTpSSTmei//e1vw2u4lsJ7wSN96YCkzM7llJyjvJ7OC3P8KZnk2gdlkVK8B+la5WYEUpRG8j7za0tZIa8zXZPOE1MmSYmjn2tVgun7PLaF/OWcSCQSdYh8OCcSiUQdoqGldJtssolWXnnlsCeYJF1yySWlZvvNvb6k2HJzHzYGnnh4OeVIdIq5hImuKLa0DPKXYrvE0G7SA9xoQIoB7+6yIihVogTQs7FJ99DB6E4v0h+UCTFYiG2+gy0kx1uKrkdSR745AekGXk9+J6e52OpTyuhSQY4R23RK8aRIRVDKxcAmKdJA/E78XIZdSZFS4Oc6BcDvREeszwfKKSnhY2tOqacU23l+p5133jkcx80JKPXztp1SM34n31yDsksG51Ma6aFD3AuR9I7L9L7whS+UmtfPd2vi+3Eu+wYCBCmY22+/vdSkqKRPvt+iRYt0++23p5QukUgkGhH5cE4kEok6REOrNU477TS1traGVXEprghT2eDOHrZzpCHYSvtr6AIbMmTIYt9Lis4/7lPmgSwM2+HqLumUu+66K7yGrTlDn+jY8vegs4qBPFJUddA55ufK47jyz/Am3zeSVAZbeFddcD86qge87ePKP9t0qhLYlkvR6UVFgGdFU3XClnvGjBnhOIZkkbpgUJEkjRs3rtTMtSYl5G01ryffz8eVKgoqVagMkqLLkHTKklyFpPXo9vPvd/TRR5ea4+WKncMOO6zUDHpydx6vNWkE0mt+P5Im5PV0ly8pOdKZTvGRGuF9S2qSQUdSzNDmtXUlSHXuuiu0LeQv50QikahD5MM5kUgk6hD5cE4kEok6RENzzm+//bZaWlpq5FsM3aazykP5yTNTosUkL5fpPfDAA6Wm3IpyGge5MJc6kf8iP063masdyRGSH2SymySNGjVqsedw3nnnhePoBOSeiR6uTgkf+XG6qpyfpVuTfC/PW4ocKl/DMZGiu44cNtcdXEZFvpG8sqfX0VlIt6Xvy8dxOOqoo0pN3lyKexRSAsa1AUq8pJiaRwcjpXhS5F7Ju3rCHL8juWlK5FyuSH6V6w5+LeiMu//++0tNrlaK85fzi7y3JA0bNqzUdNzy3vQ1CH4PJkE6r8tx4WsoQ5Skgw8+uNQcOzoOfW2HEkxKAC+77LJwXHW/yPfff1933323/hHyl3MikUjUIfLhnEgkEnWIhnYI3n777erYsWNNIAtdfJtsskmp2dZJUQ5GKoMuIQ9QYStHaZKH3lBiRRmbt9Js8+gWPPbYY0vtrWpb4f1siaUoISPtwi3kpdhyM2R+0003Dcex1efefvxzhspIUXpIV5u7yEhLcEzo9pTiNezXr1+pGdjktAY/a0nh8TwHBuU4Hcb/phvRg+DpEKM8kPSOj/G0adNKzd3pXSLHVprfwzeUoJzynnvuKTWDp55++unwGtIDlKVywwB/b1IUTmuQVuK1dXzta18rNceB5+DyR0rhSGX4/CJFRLrJx5VUJ12svM9cKkjJHClWDz6qUjLz58/X8ccfnw7BRCKRaETkwzmRSCTqEA2t1njttdfU3Nwcsmml2GYzu5h7v0mRyqDbjI4kdwNRKUHlAKkQKTr/SCPsscce4TgqIqjkoMOJLbsUV5TZYnmLxDaUygZv++nu4uf6uJLGYdvIwBoqZSTp3HPPLTXdU77yz/aSTsQDDjggHMfPmjJlSqmPOOKIUnv2MTO52bI7BUDVA9tbd9BRKcH55S4+tsKkvehCcycb1Rtc0adKSIouRdIB7v7k/n2klejQ9O9HKorHOV1BioItvGeb83ryujtdN378+MX+HV2rHlZFapL3mStseA5UA/E+leL9TmUPKUPmWEtRcUUXpYc0VSnRdAgmEolEAyMfzolEIlGHaGha489//rOamppqtiViC0m6wVfnKb7n1jrMnOXKuhTbHtIfbIOlKOSnScMNIKQi2GazfXe1AEOVeK5OVzAbmK2rq1a4RRSVIBT/S5HK4HuzNfSVf7aXzCT21o4r//xcN8LQ6EF6gSYWtvlSpBF4Xfy9qcQh/TR16tRwHCkitsief01jBtvqrbfeutSe00x6gOoRV4Jw/K644opSe+Yyg4a22267UnM+/Md//Ed4DdUVpLw8pIlKCdIQpBqkSGVQBeO0BjOhOQdID3lQEY0eAwYMKPXDDz8cjuNz4MADDyw1r4sU7/cJEyaUeujQoaWm6kWKihvSUq6eqo6Lh6S1hfzlnEgkEnWIfDgnEolEHSIfzolEIlGHaGjOeaWVVtJKK62kq6++Ovw5JWnkUwcOHBiOo1uMe3/RGURuVYrSKYbge4AK+W2GjTsfSkcdQ1OuueaaUlP+JUWpIHnJm266KRy31VZblZr8rIc08f0I/04cI7oPGQTjsj/KsvgalzXSaUcJkkuiyNGSr6es0fcnJA/O9/NNGshzct74ceQSKe1yXrhXr16lJl/P7+DrBJQbkg+98MILw3HXXXddqckZky+WIofK704e3vfyIxfP8+FrpDjHyeNyTUSKLl266VxOyfHjuZKj9THm/KLzzyWwdPpSHkjnphTXhyhDJHfvHD2vJ3lzPiukT+51dy+2hfzlnEgkEnWIfDgnEolEHaKhg48uvfRStbS01ITHkK7YfPPNS+0SGEqfttlmm1JTnkMnlqRAoZx11lmlvuiii8JxlPXQmUXZk58fHXmkCti6SbHdZQDON7/5zXAcQ2LYevkee6ecckqp6bLq2bNnOI7SoosvvrjUV155ZanZWkoxnIhtsNNFDAnie3grzXGhM4tSSLo9pdieckw8hKpPnz6lJpXh+x3SIXbHHXeU2jOX+X4MtaKkzdtvHkdZnAdwURrGc/VrS0qA+xjSNUl5mxTlgZwPp556ajiO70e5J99bipI53mceYkRKhvcwqSNmMUvRxcf7wqlA3me8vy+//PJwHF2ZTnm09d4cY8pznbap0kUffPCBRo4cmcFHiUQi0YjIh3MikUjUIRqa1ujTp4/at29fEybEVVK2St7usq1liAuDW9xVSCUBh85bmG9961ulvvPOO0vtW9dQWcJgGbZ8bAWluMUTj+NnSjFMiAoGV2EwrIXtJLdgkuJ29XSycRzoWJSkF154odSkbTzAhrQE20TfEmj11VcvNceVbb8rRphdTHcfaynOFa6oMxBJijTO4MGDS01KQorXg+/N+emZv6R06AJ01x2djmyN3ZVGNQhrtt/u/COdRfXB5MmTw3GkMr7xjW+U2qkHKksYhHXGGWeE40ivcbx4b/3whz8MryGVQfrPlRKkK3g9STFJbc9xujpdEcPnCqkQz66uUlgffPCBzjrrrKQ1EolEohGRD+dEIpGoQ+TDOZFIJOoQDe0QXH/99dXU1FQTFs49BCk5opxGiglX3KeMPJBzzuRGKYPi6yXp/PPPL/UNN9xQarqlpCjLomyJKWuULElRAkh3lydxcVx4HPlKfz/ye9yMQIoyLXJzlKqRE5ai6/HSSy8t9bbbbhuOo9zqS1/6UqmdkyPPye/x2muvldqXUSgVozvSZWy81kyoe/nll8Nx5JIpz/TgdvK/5CXJibv8jrJLptpRlifFtYrp06eXmqloUgzpp2OR48CkPykmIpJDdS6Z84vfyTdp4DWjFPWCCy4Ix9Et+9FHHy32c31DAzpuySV7miRTI/lM8PGnpJOcP7luX4vhBhOHH354qR988EEtDr7BQlvIX86JRCJRh8iHcyKRSNQhGprWWG+99dTS0qJx48aFPz/zzDNLTQcdQ/ilGPhDGQ5bWg+9mTlzZqnpyGMwiiTtu+++pWZYy5LcWAyZ4XHeRjGYhjQEpWWS9Morr5Sari2XsVGKyL34jjnmmHAc22KOEeWFM2bMCK9hSAz3A3RZ4xNPPFFqSrl8G/rddtut1P/1X/9VasqWfHMC0gOkUzx0iCCdQopJkp555plSU4rl7SrpEJ7fkt6bckrKEkkdSbHlJhXiVA3bdF4nziGX35EC4HfyzQRIYXHuOq3E9p7vzXGU4nfnXObnuLOU15NUG8dEiuNH16+HNHH/SdJ6lKz6fo6k7jjXXNpapX58j8W2kL+cE4lEog6RD+dEIpGoQzQ0rfHHP/5RTU1N6t+/f/hz0hcMKeEKtxTbFq64ctXdw3/YJnJ1f5dddgnHMY+ZLRZzh6W4Gk7agJSE73NGNxyVHJ4Tu9dee5WaLjDPSGarSJrFV93532wh6Vh0SoG5zUceeWSpOT5SdAXSJecUzI9+9CMtDvzuTkWxnb/55psX+xopKgQYqONuM44lnXYcEykqLJhXTVWB01wM8SJt8+qrr4bj6G7k3/m9wLad7k+emysgSJnwmvl8oCqKaqCxY8eG43ht+VmuLPnud79b6t69e5eatKW7Cnn/kJp05RL3IaQqihSoFF2QvE/43X0PQFJJfMb4/KreG743Z1vIX86JRCJRh8iHcyKRSNQh8uGcSCQSdYiGTqU79thj1aFDhyDBkWLqGvm9a6+9Nhy3ww47lJp8FYfEE6iYskYJGiV7UpRYkYscPXp0OI4pXeR7GWzvex/yHOja69y5cziOLin+nbvzKFVisppLDynbozuPfJzvT8g94whKEqXo3qS8zFPbTj755FKTo+Rr2uL6pMhRulOSHChdZC4ho7OUUkHfi5FrBXSicQMBOiOlKLuk5MpTD8k5M3GNPLAU932kTIzn4Bwx1zHuvffeUnv6I68N+Wzy61KcE9yb0WWEvFc598jRcl9MKbpJea5+HHlicvl+bcmd//Wvfy01XZOUm0oxOZFJl+6W/d3vfifp4/l5zTXXZCpdIpFINCLy4ZxIJBJ1iIaW0u28887q2LHjErdsp7PHg2nYgnCfODrjnAKgJIeSI5dvkR6gG+u8884Lx/HcGfzC4HGXBR100EGl5j56Tq0wZInHeevLMCe2Yk4PsOWmxI0BOB5CRZkXXVoeqkSK6cYbbyy1bzTA4Bye95577llql9uRXqCTzdtOttL8Hk4XUYpF6RupKClK+HiulC66i4wbH7Bd9mtLDBo0qNR0qEkxkIiORX4nBidJce6STrnpppvCcQwdovST11KKNBCpO3c9UvZKeoHuVpfz8TpR0uYSTLoguYGAy0opk+R3aitETIrBTPvss0+pSTdJn4z5MnUI/uEPf9Ahhxyi1VdfXa2trdp0000D11SpVDR8+HB17dpVLS0t6t27d9DKJhKJxIqOpf5wfuedd7Ttttuqffv2euCBB/TLX/5S3/3ud8O/mGPGjNHYsWM1YcIEzZo1S126dNGOO+5YsxtvIpFIrKhY6mqNM888U88880zNtvNVVCoVde3aVYMGDdKQIUMkfRyu0rlzZ1188cU1DqfFoarW+MY3vqFVVlklBI9IcXWX4Tae58wV3Ntuu63UXKV1VyFbMdIVvs/cXXfdVWquSrvjkG0V/3Hi/n/uUONr+N7e8tGNSNrF9xDk60iFeFvGz+KearzWTgGQUqAawqcd21A6BH28qJ558sknS33aaaeV2oN8GJ40atSoUlPpIsU2lkFFnudMFQxpCW+l6QwllUSXnI8Xz4G154VzLrOdd7cf5xTH8sUXXyy1qybaCj7yXHFSNfwe7qAj9UPHKGlBKVJYVLcwTIuqECmOA+ekB3Bxj0OqTPwcSDnwOcJnAjPYpUhTkVby51J1DixYsECXXXbZv16tcc8996hHjx7af//9teaaa2qzzTYLPOEbb7yh2bNna6eddip/1tTUpF69erVpzV2wYIHmzp0b/pdIJBLLM5b6w/n111/XlVdeqe7du+uhhx7Scccdp5NPPrnsBlL9teK/GDp37lzzS6aK0aNHq1OnTuV/rk1MJBKJ5Q1L/eH80UcfafPNN9eoUaO02WabqX///jrmmGPCdvJS7YpnpVKp+bMqhg4dqnfffbf8z4OAEolEYnnDUpfSrbXWWjWOvQ033LA4laoc8OzZswO3NWfOnJpf01U0NTUFOU4Vu+yyi1paWmrSrchFkmdz2oT/GFACQ9cW3URS29Idyp6k6OrjHoLuOOQ5VB1EUnQs8vtIUd7HvfOYqibFveHICzPxS4pSKibZOYdK/p1OO7rk6Fxz8Pz8uIkTJ5aaew26nI+cJa8FpZDO/x9yyCGl5j/srhDiZ5Ev9vdjMiHfj4veUuSJyVlyXJ3P5rXhnHJukmspvBacQ1LkbjnXOHbu1qQUjpwsJZxSnMv8Ti7V5BrAFltsUWpeSynK2Hh+dF46985NG+gA9v0O6ZTkJgb+Q4/PC84Hct3+LOI6FK+fuzqrCYbLTEq37bbb1th+X3311WLh7Natm7p06RKspAsXLtTMmTODbjKRSCRWZCz1X86nnHKKvva1r2nUqFH69re/reeee06TJ08uOant2rXToEGDNGrUKHXv3l3du3fXqFGj1Nraqu985ztL+3QSiUSiIbHUH85bbrml7rzzTg0dOlQjRoxQt27dNG7cOB188MHlmDPOOEPz58/XgAED9M4776hnz556+OGHa4Jj/hG23nprrbrqqkF2JkWpE4O6+/XrF46j04vtPJ1jHuLC/+7Ro0epfQ9BbqXOgHDK76QYisSwpO9///ulpmRJii0kW18PuieVQWccNxaQpLPOOqvU48ePL7WHx7DtJC3BFtSpFbbFvE6HHnpoOI5jThmi00o777xzqen0IhXlYUmUz/H7kWqQIg1EuoiuUCk6Nik9ZCCVFIP4SYGxtafrUooyNH4nlxRy3nAeuuyScjyCFIwvsHNcSKe4lI5zgOdKh64kDRgwoNQcI24uIUUJH6kkBuA7zcWAKoZieajVlClTSk0qySkGUkS8t5a0RyK/O6WLziBU7293NLeFT8W+vdtuu4WNOB3t2rXT8OHDNXz48E/j4xOJRKLhkcFHiUQiUYdo6OCjyZMnq0OHDjUtDFeyTzrppFK7u4jOJdIIbM0ZXiPFcKK2AnWk6Iajg8gNNDwHUiZs8Vz9QrqBLR9bPCkqDth6UZkixX3svv71r5fanWNUN3Almm36ZZddFl7T1t5+3tpRIcDv6206/5uUB51xHr7E3Gc6yjwugPvt7b333qWmY1GK48WwHipOJGnw4MGlJg1BlYLPL84BUj90OUpRMcLvyz0SpUgrccGdc8VdsJwrG2+8can9mtE9yL/zff74d8xcphFNiuNKKok1720pzleqolz5xSxqZkCTApXidyflQbes06N03E6bNq3UvEbSJ0oTd+i2hfzlnEgkEnWIfDgnEolEHaKhaY3+/ftr1VVXrckGbivj+JlnngnHcdt3p0aqOPXUU8N/s82j3dxX9KmcoMqBtIgUWyy25lxB9+/HFXgqAjzYiaYDqgC8NaRqZdGiRaV2JQHVJKQEGAfryhLSEG2F/0hxKyO2pE5R0IRA8wxDanj9pahMIDXTp0+fcBy/H9tTV2FwrpCyctUD6RCaQ2gi4nySIlVAGo5GHylmLnPMfdsrqjyoGKEiw2MTSGedffbZpfbsY87xY489ttSugKAB5MQTTyw1aTcpKmQ4p6iaoELHvwfnLs0pUpxTfG/PqKZhiVQGzTyuBuLf0XzGe1P6hNLkXF0S8pdzIpFI1CHy4ZxIJBJ1iHw4JxKJRB1iqYft/ytQDdsfMWKEmpubawKzyUNRdkapjhTdXXT4UcrlHB55RXKCzrWS5+RxlMhJ0tNPP11q7gVHSZQ7J8kjkqdzWRAdWBwTcm5S5MwYMu88Oh1P5PJ5fh5oRFkiX++ON54f+VXnpsm3k68lD0h5mxS5X0ocPXiHsjby486NkjOkHIycpxTHhesGXGfgeoQUJYrkn91txmAf8vUetkNnHOck1yOcA+X9xOPaWpeRopPQg6I4x3kOzreTJ+b6EMOEPLyM/D1liHToSlEqy/fw4CO6bw888MBSP/HEE4s9RpIefPDBUnMvS5fNVh2yCxYs0Pjx4//1YfuJRCKR+L8jH86JRCJRh2hoWuPss89Wc3NzkDNJUeZ1wAEHlNrbEbY+pDjo5nJKgbIjtiSe50zJD+VbLk9ju7rjjjtqcfA2nfnOdBt5hi3lQ4xoZcCPFN2NdNMxrEqKbRplWWznvU3n3m10C7pLitQBpWt0Dkox5Oexxx4rNdtbUi7+3qS2nIriObG19/AlShHZ9q+//vrhOM4PytCY//urX/0qvIa0C2WXdIJKUfbH6+6SO57TnXfeWWrSdQydkiLFRPenu+44XpTPeaY07zvOf89F3nDDDRf7PbgXJkOxpCitJA3nFBMznPndXapJCozOScoG/Tpfc801i/0chihJn0g8Fy5cqKuvvjppjUQikWhE5MM5kUgk6hAN7RD861//qqampiU62bjC7OFEXKVmy+0KDYIr+mzrvJ2ne+2II44otVMwbJ+5ek0awlfJuYUV278HHnggHMcWi62lqzq4jfzQoUNL7dtj8bMYnMPz8ahYKg5II+27777hOH4WKQBXjNx4442lphqFdIVTUcwXpvuNKhUpXkO2sb4JBCkdjoM76Dj+dJqyLSbtJsXsY9JPzLGWYpgQFRo+D0kD8HwYysO5KsVgn8cff7zU7vyjA46Uhwf+UM3gKgqC1CLHhTngPr9433Ieb7nlluE40hVtZWFLkbIiVdmW4kSKjlRSYE51Vj8rHYKJRCLRwMiHcyKRSNQh8uGcSCQSdYiGltL9+7//u1ZaaaWa8Gs6isgDMh1Liqlk5CnJX7766qvhNeQY+bl+HGVaa6+9dql9HzYG0L/zzjulppPwuuuuC69pKwDdpW8XX3xxqclzuouMkjR+roemjxgxotQe2F+F85KU35E733rrrcNx5BU5lv5+lBXyOtGJ6Lw+OUJy4Mccc0w47rnnnis1x4hyOSlKxfi5zvcyCP6NN94oNWVedKFJUXZJiZtz79yLkk5H38ORIfP8flzr8GvBOUoe2Pcj5LguaXMCnuu3vvWtUnM/Ryk6c/nevJ99vYSyS34nSuyk6CAlH+1zhc8BOhZ5LTzdknw70x9dult9v3nz5unoo49OKV0ikUg0IvLhnEgkEnWIhqY1Tj75ZDU1NdW0JgyC4b5pHlpPuRqpB0rzPED9qaeeKjXlPr53G51VbI9c9kcpENt+Bgi5dIet3De/+c1Su+ONlALDlzwAilIxvre3XJQg0dlGiZ3L79hqMoSKdI4UW27Kpa644opwHFtIjh0lcpS6SZGG4OudmuF14pziPJFia83bx78TpXp03fFzPPyHlALnkIfo8NrQyeaOQ4ZckZbiHHj55ZfDa+iw5XdyxxvnJTdsoJRViuFCbPvdmUgnIGWEvOfooJSkhx9+uNTbbLNNqX0Dgf3226/UvAe5b6QUaRfSMwxzcikc7xneZ773Z5VqmT9/vk4++eSkNRKJRKIRkQ/nRCKRqEM0tEOwtbVVTU1NIYNYinvp3X///aVmjq4UA2io3KBawPejY1tFt5M7vRjiQlCVIElnnXVWqYcNG1ZqKijYkvm5sgWdNGlSOI7ZsmxJfQ9BtnZUf7ib6wc/+EGpqTgg3cFWXIqUB9tTz/xle8/W0MOgSPeQvqDqgY40KbaXVF7MnDkzHEe1zP77719qDz5iFjWpC6es6KCjioJzyikY0ilUzvjcJZ1CFx8drFIMniJlQjWK73XHtp2tvbfzbVGBvuci9+XjtSWNIcVrw/nFOeU0I92fpEycCqSzlM8HqlH8nHhtSc14JjvPiQFcTvFV54ArkNpC/nJOJBKJOkQ+nBOJRKIOkQ/nRCKRqEM0NOfcrl07rbTSSjWpbeTGKKnxveAouaPcipySu3wo1yGn5M4lcnDkq8gPStJBBx1UarqTyFm7q3D33XcvNSVangZGZ9bRRx9dasrWpCgV4/k4N0ZZG11W5B6nTZsWXkOX3NSpU0vtIedcNxg9enSpOd5SHFe60vjeLjtjMhv5e+eS+d2fffbZUvfv3z8cR8fmkUceWWrnUHlt6GxkmqHPyRNPPHGx58e1EynuXUg5mV8zrqtwftHN6HI+rkHwXnCZHrlWSlbvvffecBw3A6CbkddPitJIziMmx7k7j4mIXH9xRyXfg2NOR6a/xw033FDq448/vtR0mUpx0wDKAz3dsro2w++5JOQv50QikahD5MM5kUgk6hAN7RB86KGH1LFjx5rt0ik7ojzKA38oIWLLxiFxKRddhqQD2N5K0osvvlhqtlTedl566aWlZlt9zjnnlHrQoEHhNXQVMWDcw94pL7vwwgtLvcsuu4TjuN/hlClTSr3pppuG4zhGbHfZLns7SXqAsi6XsbHVY9CNt/OkQ+hEY2vp1BHPiTSLSwU32mijUpOmYksrxYAptuy+t9zPfvazUpMeo7zQ5wPPlXSYO8k4DrfcckupOW+kKMmkfJHf3Z1slItSlsjwJilSCtz4wOWnDB3ifHDZH+nItvbs+/Wvfx1eQwqLlJfvu3nfffeVmhsaUNonRRqNm1fw3uKYSlHeyfPxPRermx1k8FEikUg0MPLhnEgkEnWIhqY1zj33XDU3N9dk2LrCogqG4/hxXGmn+sD3buN29Wxpfb8w0g1OpxBsY9k2svXl3m+SNG7cuFLTCeVtFFs0tpoekEQXGHNwfbzYslFxwPH30BuqZX7zm9+0eRxpBO7XRrWBFMeCLTcpKioHpDiupKk8yIfg+/G7SjEc59prry01aREprtyTDqP7bUkgVeC3KdUWHDtXDdFNSvUOv5/PXZ4rKQ53MzI8iW46zxVnsBLpMN4jUtzjk9+X701HoBTvQaow3CHI92MutTsOqRrifUHlxgknnBBew/nPMfJzrQaMvf/++9pjjz2S1kgkEolGRD6cE4lEog7R0CaUL33pS2ptba1Z8ab4ny3p1VdfHY6juWDfffctNdUfl19+eXjNaaedVmqqAtz4QIMLTSNsg6UYGsTV6ptuuqnU3kZxdZi0yJJaJCoqPKCHihaGPvmKN2kJ5jSzjfX8ZbakDIfi95ZiHjDVLa5A4X+TxqEpxsOlSF+xDX7iiSfCcTvssMNi389NB6RdGNbz2muvheOojqDZgav9rvBgcA4/xxUQbL9poPJAKV53qm1IKzEISIq0Gc09vq0XVT98b1IAUsyEppLKlTg8V1IFNK7wXpLitaZph5SQFKkoUhxUhUhRWcLz4Tg4jcrrRCrRty2rPpecJmsL+cs5kUgk6hD5cE4kEok6RD6cE4lEog7R0FK68847T83NzTU8G51L5IM8IImcEnlFBp57yDn3CiRvx/eSIj9LbpRh9lLkiSklogyHPKkUOWd+J/K2UnTdURLl0im65hjqQ9edFCWBHCOGq3uYDffLoyvQA8vJCZK3Hjt2bDiODkbK9MjBupON15aB7BxHKfLt5CIprZSkX/7yl6Umt+kbDTBEhxw7eWrn1LmhAcOqPFSJEk8GH/m58nM5pxic5JK2b3/724v9O1+DoCST6zy8/6TozqPDb+uttw7H0ZFKjp3XzNdL6JTkcbyWfq7kwN1NynPg/Of4+xoX733e3x6sVf27RYsW6fbbb08pXSKRSDQi8uGcSCQSdYiGpjUmTJiglpaWmlaHbS0dQFdddVU4jk4yvgdbIM9epWONbQu3p5di68M95y644IJwHIOP2PazrfOgIrZbdHr53m2kXbhv4LnnnhuOI6XA7/79738/HEcp1e23315qtqdsb6VIPXCM3MFFOR/lTO725PcgzUIaiVI8KV4n5mS7tJLuSMoXnVZi0BCDc1yWRZcn22W29h68Q2qEjj53iZKi4Hf3/TR5rqQAKEHzYC1K1ygb830xmdu8zz77lNqvLZ2YnB8cHylSMKRG6Pyj29DPifc9qSdJ2mOPPUr9+uuvl9olipyvlM3yvT0Dequttio17xkfr+p1X7hwoaZPn560RiKRSDQi8uGcSCQSdYiGdgi++eabampqqmmj2J7SBXbccceF49gakobgCjpVCVJs2ZiD7NsNsR3ndjXMKpZiC8+gFbZE7mSjG5Erxb4tDr/f4YcfXmrfloitMFfkXUlw9913l/qb3/xmqdkuu3uK4T8MjfKVf35H5lB7aBRfR1XHkrYjI+3C68lVez+O2ySROpKiyoNOUA8d4jnRQUcqw8OSGJxDlYk7UOlYO+mkk0rt1B1pEtJevC6u8iElsOuuu5ba7wVSYDw/OhalqGDg9/OtyjguVBBxayq6OKVImfB86EaV4pZy/Bx3f5L+4PZwpORc7cR7nXQM89mlT2ib999/X9OnT9c/Qv5yTiQSiTpEPpwTiUSiDpEP50QikahDNLSUbvTo0Wpubq7hWrlXHdPd6JKTokSNvBs5a8qUpCj/Ic/mHCo5S/JYzl/SyUTOk84/Jl1JkW9kqpmH6DP1y2U9BN16nA7OMVJORC6SKX4+DuTRmVDnzktyjJR/eeA/pVQDBw4s9TXXXFNqX1sgt3n22WeX2l2d5OiPPfbYUnt6GtMDycs7P37bbbeV+owzzig156tfF7rchg0bVmpK1aQoSWN4vO9l6Q64KigJ9fuC8lHug+hrO5Si0rnpXDLD+zmXyelK8b6lu5LnyjREKXLOlDK6/JH3E9cC/DtRZtevX79Sc89FPweuNfC7e9h+NY3ugw8+0EUXXZRSukQikWhE5MM5kUgk6hANLaVraWlRS0tLzd55bKPYgmyyySbhOLYwlPvQYebSHcqM2OazHZUiZUL3IT+z+h2qoMSHtMHEiRPDaw499NBSk47xPd5II7AFpRtPijJCOv88hJ2yMY4D23SXp5G+oKPM3Yxsd9nCU2ooxWtDyRblgAzakaLbjyFZ3E/Qz4luTXeg0nVK9+eYMWPCcaecckqp2wrg8v0EGWLEcCIGUknS/vvvX2q2/QxVkqK0kTXpMErVJOnZZ58tNYOYGPolRXqAlJy7OjlH6a7zvR6//OUvL/Y4Stc8vIw0AueX71HJTS7o1nQ3KTdMoLOUNJKHS5H+I43k1N32228vqVaK1xaW+i/nv//97zr77LPVrVs3tbS0aP3119eIESPCxKhUKho+fLi6du2qlpYW9e7du8YSmUgkEisylvrD+eKLL9akSZM0YcIE/epXv9KYMWN0ySWXaPz48eWYMWPGaOzYsZowYYJmzZqlLl26aMcddwyLAIlEIrEiY6nTGj/+8Y+15557qm/fvpI+XsGeNm1ayUOtVCoaN26chg0bVtrX66+/Xp07d9bUqVPDvn7/CJ/5zGfU2tpa00axzai2EosDA4RILzCAheEzUmyrmKnrzqyjjjqq1GypPMCGjkG26XS/+Wo6z3VJrRypFtIQHh5DZQLziX0lma9jm0eVwvXXXx9ew/aZ+789//zz4TjuhXjPPfeUmq29FGkXp3Gq8DlE1QRpBLblUqTAmpubS82wJSmqDEhfufKCWdakhEgDkSKR4lhyHnpIEFU/pAO4/58U5w73RSR90qdPn/Aa0j0jRoxY7PlIUelApQUpISkqeAYPHlxqd8k99dRTpea9QMUUs6Yl6X/+539KzUAvV4IwkIj3gisq2gpKO+uss0rtgVlU7Oy2226l9lzxqkvRXYltYan/ct5uu+00Y8aMIhH72c9+pqeffrpwqG+88YZmz54dbrqmpib16tUrSLKIBQsWaO7cueF/iUQisTxjqf9yHjJkiN59911tsMEGWnnllfXhhx9q5MiRxWde/bXii3idO3eu8eRXMXr0aJ1//vlL+1QTiUSibrHUfznffPPNmjJliqZOnaoXXnhB119/vS699NKadtdXlSuVSs2fVTF06FC9++675X9vvvnm0j7tRCKRqCssdYfgOuusozPPPDPIly688EJNmTJFv/71r/X666/rC1/4gl544YWQ6rbnnnvq3/7t32oe4otD1SF4+umnq6mpSQcffHD4e3I6DNN2LowOMXJNdO25G4j/gNC95vI08orktZxjPOyww0p91113lbrqJvLzlKIjibIeSqqkGOpOBx75XUl64IEHSk3KyPeCI3/53HPPlZpTiFIkKaaD8bzpspNiahi5UV8kJv/Ibuqcc84ptTsqyf2R033sscfCcUxwo8SK5ybFdYKLLrqo1OQlpTiWdG9STkkuWoo8LGV/TuWR72XH6VJNcsFMIyQn60mCnHvc19L3fSTfy/ngHH1bDj9KPaXoJuX6BO9hl7Hx3uDago/rgw8+WGquB/maFDl7ygO5PuHSSirNeJ85E1BdJ1iwYIEuueSSf71DcN68eTUnv/LKK5cJ0K1bN3Xp0kWPPPJI+fuFCxdq5syZNbrHRCKRWFGx1Dnn3XffXSNHjtS6666rr3zlK3rxxRc1duzY4vlv166dBg0apFGjRql79+7q3r27Ro0apdbWVn3nO99Z2qeTSCQSDYml/nAeP368zjnnHA0YMEBz5sxR165d1b9//yBzOeOMMzR//nwNGDBA77zzjnr27KmHH364pn3/R1hrrbXU0tISQkmkKDtia+EB3KQRZs2aVWq6zVzCRPcUA7hdHkN5ElUo/n5sKdnCU4blYUKkSdiqMtBdiqHzrPkdpCjLYhtLJ5W/P9tEOi99v8MXX3yx1Gx33VFJ+Rbphr322iscRzqEFBMpGG/T6SIjteU0BJ1bpIT23nvvcFxVFirF/ePcIciWmRJFUhJ+LehIJR3j4V6UtXEPSKesSDnxPmEwkNNh7GDp7vP99kgR0Rnq8lNKXUk30PsgxQ0ceM9w7Ei5SDGkjBsI+DkMGDCg1KRW/P04304//fRSU1rp8k4+VxgURdpWUmEL3BXaFpb6w3m11VbTuHHjavSWRLt27TR8+HANHz58aX98IpFILBfI4KNEIpGoQzR0nvMll1yilpaW0M5IcVX5zjvvLDX3sJOiw4+0BNsOz4Vl28jAIN+Hja0+V+o99IQZtAxsYhCTL5SSomC7y5ViKX5f0gHM65WiI480iY/XhAkTSk2HGQObXIXBPfLoMORqvKQgj6QLkw5DKToi2Y7zmrENliK1QnelUwCkPOhEY2iRFNt0UivuSrvwwgtLTWcjx8spBaoROIfcbUbVCucAg5j8PehsI63kC/hHHHFEqa+88spSU1kkRZUCaSW/HzmPSIUwi1mK85r3I1U+vgfnSy+9VGpeW9Z+3PHHH19qOhYl6cQTTyw16StSGU4xkaZitrbvZVkNEnv//fe14447Zp5zIpFINCLy4ZxIJBJ1iIamNU455RQ1NTXVGDuo+mCr6eJ4bh106623lprKDYYCSdGwQcqD9IQUVQ/evhFcLWZ+MnN0hwwZEl5DQ8KNN95Yam+ReU5UrXg7zzxfBrf4+/Fz2XayraN+XYqr6VSZuBKEdAjNCZ4pze2oqKKgkoTmCCkqGxg8xRV4KVIAHC8/jkFWpG3cVMH2niYG0iIevsScZo6XK3bYDj/xxBOldkUS5xFpKaqn3CzBcSBdxPAgKSobOFd8HKiOWFKI0R133FFqKlBI6Xi0MGkSmpf8niNtxvvWVUO8nlQxMcvaaUZSkFTb0FQjSQ899JCkj8f01ltvTVojkUgkGhH5cE4kEok6RD6cE4lEog7R0JzzXXfdpY4dO9aEDjFEn3ycB7zTAUSOinyo73VHMOTcXYqUX40ePbrUvr8dOULfo62Ko48+Ovw3g+7pSPKQIIaKk+u7/PLLw3HkjBm842H25BXbkkR5UBRdUpQ4utSJ8jJK/TzgnVIqrhPQkUk5kxTHnDI938SAvDUlfL4vIsHjXO5GeRl5cAYseXA7eXS6MD1il05Tugw92ZG8Kec1OVh3/pFTpdvSuXdKFMn3crMLKV5bjr/z6Bx/Si355y7V5DnRCeqPNXK73JeSfLEU14A4dhxX3i9SvLbVTUakGKAmfbIWNm/ePB155JHJOScSiUQjIh/OiUQiUYdY6tka/0q8/fbbmjdvXmhTpNhqsm3xYBpKg7j/HlsvtqBSdCux3fJ9DBkARFegS3coDSJdwSAg7q0mRaqALZVL5Pbbb79Ss9WfPHlyOI7jwgxhdxxS9sXPpcTOW1/SKZTfecgV22e+H/dnkyL1w+tEiR23tJeiQ5PyL88G5vjTrenSKUoU6Xr0z3WHWBWUanpbTRqO4+WSO7rUSHm4248uVn4uZXp77rlneA2/B+euz3F+P1JRpPv8cxkGxXApKcoueZ35HQ4//PDwmrvvvrvUpMrcWUrqh3SW7yFI+RuvO+mHGTNmhNcccsghpWaeubuLq5/l1ExbyF/OiUQiUYfIh3MikUjUIRparTFjxgytuuqqNbQGqQe2ZR5Ms88++5Sa2cxcmfW2hyvy3KbKtzziajNbX3cztrVqTlqD6hMpqjDYFu+7777hOLbIbHfpQpNiK8Y2sV+/fuE4KjnY2tMN6d+P28szo9q3kqL6g+2uuzp5bUhLcUshz/IlNUIHmOc+k4o6++yzS+3uTyoT+B7exrLNZgAXFTq+4zxpIX4POs+kqEagQsbnCsN7qARhcJXTYTwHKpw8h5jUFCkm1lJU85A24zhKcfxIZTBf3e/HtoKPXMHF9ybF5yFZdJDympGOcTUQx3hJyp6q8mjBggW69NJLU62RSCQSjYh8OCcSiUQdIh/OiUQiUYdoaCnduuuuq9VWW62GAyLInzHpSmqbu6UsyF1kdOGRC3PXEMP36WpzORJlcTwfuqr4OX4OfO+RI0eG4yiFo/Tq/vvvD8e1FYY+derUcBx5YnLYdEKRf5YiV0rHGxMBJWmPPfYoNceEGwH4+3PMOV4utxo1alSpyUu67IzyLZ4D1xYk6fXXXy+188wE0964pkFppO8pSb6d/DhfL0WJIp16Ln8kd0tumjy6f79p06aVmveCb8DM8e/Ro0ep3YHK+44cPcfRz5VcLNdEbrnllvCaL33pS6XmfeJSTaYtMlXw0EMPVVugtI/cu+87yHHg/PTnUnVNyTe7aAv5yzmRSCTqEPlwTiQSiTpEQ0vpHnroIXXs2LHGccMWl+4p7uMmxf3y2JqwtXSHGlsdOtlcFkTnH9sb7s8mxYBxtmgMGXInFfc+ZOvsl/Lxxx8vNbekd7kbW1y2kE7p8DwYCEUJmrfVN9xwQ6kpeWQIkhTbYn4ntuyStNVWW5WawUx0eHrgPx2ClDyecMIJ4TgG3fBcOZ+kOC7cJ5DfVYpzgONFSSE/U5K23XbbUnO8Ka2UovyNUrUlSch43a+77rpSMwBMimFaDDFyNyPn1F133VVql5PxdZRC0lknRWkkZZyk4RgmJcX7lntA+j5/vNd5Di495F6BDDPjnDzwwAPDa0gDcYydNqvOgYULF+qWW25JKV0ikUg0IvLhnEgkEnWIhlZrLFq0SIsWLQoBRFJcDaU64qCDDgrHVff0kmLbQpcQc5ml6Chie+v71lEVwFafK/BSXKFm7jDpGKdt6Hrk6jedSpI0YMCAUl9yySWl9qAbfne2sWxbpRjaxOxcrrrzz6V4Lej269mzZziOYUykLpxaIVVDFx/dkCeddFJ4DcOOTjvttFI7DcTgI6ohPEuZLrcnn3yy1E5/0M1GxQLnnYcvkVai0sXPlcc999xzpeZ8kqISg9QKg4E8s5ytNqkjBjFJkS4iDTFlypRw3De+8Y3Fvp+rFnhOY8eOLTXHjjSgFFU1fL0rs3g/0rHreeH33ntvqTn/Oa6kT6SomOL5UBUifeLMnTdvXo3qZHHIX86JRCJRh8iHcyKRSNQh8uGcSCQSdYiG5pz//Oc/a/78+TWpdJTD3HbbbaX2IHjKcrifGXktJnlJUWJFqZMHrZN7oszLU7UotyInS/kR5XtS5M/ID7rMiCH6/H7Oj1Pqx/NxPpRSP/KK5BSdo2/LlcY0MSl+d7rh3BlHDvrGG28sNblD30fvyiuvLDWdm+RqpegwY8IfJZNS5CwZvO7JcZSxPfDAA6Wmk5PuTCmukfBcN9lkk3Ac5xHH37lMSjIpV6TckDIzKbrr2pLsSZGj5xziXoVS5MspFXzmmWfCcZMmTSr15ptvXmrOd66dSNJxxx1X6oEDBy72NVLcjGHYsGGldnktZYQdOnQoNcf72GOPDa856qijSs3NOXz9pfqM8HWBtpC/nBOJRKIOkQ/nRCKRqEM0tENw3LhxamlpqXGRMWCHLa1v2U6ZEVsNuqw8OJyOJLbsHuLClpb7v7EF9c9lO3799deX2ukYtnJsY91tRKkTW1pvq7hvGs+BAUtSDHyhdIqtJls8KW5OwEB8BplLkZLh51A6J0X6iEFMdHq564v0E1/DFluK0i5ufMBAKilKthha76H8lE2SGuEc8j0l6UojPUAJmhTnHqWHDspMOZf5XVdfffXwGs4Bjh0/U4oUE+WeLn+k9JNt/8UXXxyOO+ecc0rN+c/P9Q0gLr300lLzfvZ7gU5fbsbhLj4GJFFOyfHi95Hi/ckgK9/MoUoZzp8/X6eeemo6BBOJRKIRkQ/nRCKRqEM0tFqjpaVFLS0twaEjxVaRbb+vInNPNLqkqI7w15CioFtwSSv/bEnpKJMixcDQFK6ge9vK82PL59nHPD+GJVEFIMV2kEoEV0qQLiJ1wH0Q/b3531QIuBKEK/ccYz8HjgtdhmzZPUyILS3VFa6w+drXvlZq0hBsxaXolCMdQ4WBFK8tVQB093lGMr9fnz59Ss0WW4pzgOfDbG0putxIu3D8fe7Swfj73/++1B6QxHMgfeL50JxTnAOnnnpqOI77V/I7Ue3k6hbeGxx/dx/yevK8nS7iXOYejhwvUoRSdALyvnfKinsI/jPIX86JRCJRh8iHcyKRSNQh8uGcSCQSdYiG5pz/8pe/qLm5uSbonk4hOu0effTRcBw5PcrOKC1jLUU5GF1IdFJJ0bHGFDPnUOmMGz9+fKkpK7rgggvCayjl4p5llAFJUTr43e9+t9TueiRXzfdziRX35iMfd/7555eaQfJS5BsZyu+JXeQLyb37+5EX5vhPnz691N/85jfDa+heo4vPw+OZjMfzoWtSik5J7i3nYLIaw+j5GnLRUgyJZ3g/nX5S5PzJJXvIPPlfcvlc+1hSMD1dcr4n3vbbb19qyss8xY/3FmWqdBhKcV2EHDbHzl13lMXxXvXAf8ohef/45gTkoPndKQklDy9JBx98cKm5P+SXv/zlcFx1rYFrXUtC/nJOJBKJOkQ+nBOJRKIO0dAOwccee0yrrrpqkP5IUcJCiRxDZaQYks0WhC4fl1s9++yzi/0ctvz+33QFejgOKQU6ykjBeJvOUHeGGLk8jc4l0hB+ydnakdZwhxPbZ0qYGIjDll+KEjmGHdElJ0WpE+kmbwHpyCMlRHhLy9aedBEpEimGVTEwi+22FFtuOtYYbiRF1xzDuCilo3RLio41tvAe8E4nJt2WLt/yuVMFnZfu6CMVxQAo/34MtOfnOnU3fPjwUvM7eSA+qUDOKdIsTjOSTqGMzSWFpAY5h5yq4V6NdEpS5ue0zY9+9KNSk+Lwc63SdfPnz9fxxx+fDsFEIpFoROTDOZFIJOoQDa3WmDBhgtq3bx9aVSm20qNGjSr1RRddFI7jqitpDeYEcz9Bqe199Lzla9++famp1vDAH7rIGJ5ECsGplV133XWx78d2TZIuvPDCUpPeoRpCilm1HAfuLejHcRxImfh+dKRJzjjjjFJT4SHFlXG2k66wYZtNSoBBOaSeJOmUU04pNbOKvf0mSM+465EUBQOSnKphy8q5xvH3LHI6AemA9DznW2+9tdS8Zj5XSCXtvvvupf785z9faqdWOK/pqHRVFEOH6Ealk1SK9Br3yXTnK+cRKUfet07TcB4yMMv3c7z88stLzXuOFKYUlSE8Bx7HsZMiLcjx9lClKgXje4K2hfzlnEgkEnWIfDgnEolEHaKh1RpXXXWVWlpaajKXuVLLlfG99torHEfK46yzzio122I3QbDtZFvmLXJbCgZvIRnQQrMDzS40p0jS0KFDS+3bPRE0KhxwwAGldhE9FSMMevLtnqicYHgL21ZvqynqZzvo14wKCI4l6SEpmn1ozOA4+LVg68tzYAiPFFtmmg7crHL//feXesSIEaV2WoNjQXUE1SP+3vw7Buz4uFKlwHnjGdXMFef147Zlfp1pGiEF4GYVV4ZU4VQU7zNSb24AoaqJ20dRNeSUHJUmNPeQbpKiMoQKJ6ctL7vsslIzN533jKt3SDFxDrhyqUq1zJs3TwcccECqNRKJRKIRkQ/nRCKRqEPkwzmRSCTqEA0tpXvzzTfV3NwcJEdS25Iv3zaeXBg5S/KS7pJj8DfpeqfuyfeSq2PoihTlatyzj1zkuHHjwmvIqZKLpMROipwqXV+zZs0Kx6211lqlpmuOwTtSHEuOA0Nl6OaSIv9PCZGPF8f829/+dqn9mnENwLnSKjbccMPw35SGcT2BjjKpbe59zz33DMf17du31Bx/D1Hndaf7k2Pn+zRSukZpmUu+eA3JK/P1UuRNyf9z7Mj3+3nzunjo0E9/+tNSc4MDBvxLcUMIXhvf+5PfifJA8sccE38/zj2/tlx74uYLvi8inb2Ux1KC6VJN8vccEz6HpE/mbkrpEolEooGRD+dEIpGoQzQ0rbHpppuqtbW1ptVhm05nEJ1dUnQyUaLFnOCJEyeG11COx2ATOuGk2Oq4U4hge8m2jFIuB3NwSQ+41IlyK34/d2Yx55cUCltiKVI/lMKRgvHWnt+dY+RSJ6ciqvAWmVIx5lezjfUgH9IupCvcAXnssceWmnQMg238dZRLeYgOZVV0f379618vtbsPmbN87rnnlprUhRSvLeWYbNmleD0o7+R8cHka35v7C3LvPSm6Fjle/n4MPuJ4cd5J0eHH8CvK+Y4++ujwmh/+8Iel9r0eiUsuuaTUBx10UKlJV0iR/jv00ENLTQqGLkIp7q3Ie9jnQ/W+cyqrLfyvfzk/+eST2n333dW1a1e1a9eu5kQrlYqGDx+url27ls1XPax8wYIFOumkk7TGGmuoY8eO2mOPPWq0t4lEIrEi43/9cH7//ff11a9+VRMmTFjs348ZM0Zjx47VhAkTNGvWLHXp0kU77rhj+Ndi0KBBuvPOOzV9+nQ9/fTTeu+997Tbbru1KWpPJBKJFQ3/a1qjT58+oeUgKpWKxo0bp2HDhmmfffaR9HEgTefOnTV16lT1799f7777rq655hrdeOONxbUzZcoUrbPOOnr00Udr3DdLwqJFi7Ro0aKaHGO22Wyx3I3DFoSrrNyiyLeu5z8ydHB5q8LsaDqh2IZJ0he/+MVSs8NgtjBzbqVIeZCCobPLz4FtrLfzbIuPOOKIUtOJKMXVen4uM6pJ5/hruBrvq+RUxVA94DTJ1VdfXepJkyaVmgFCDFHy/+ZrqLqQIl3EXF8PlGLID92RpNOkSAMwyIpbalGZIsW2mt/Jg3xIA3EO+bhyDnAsOR9c4dHW9kyuXOL1pILInZL8jvwenrvNfG5e55NOOqnUVIVI8ZpxTrpaY4899ig1qRX/TqSPOJb8nAMPPDC8hteM7lEGQ0mfXPdlotZ44403NHv27MDtNjU1qVevXoW3e/7557Vo0aJwTNeuXbXRRhvVcHtVLFiwQHPnzg3/SyQSieUZS/XhXCX4faeAzp07l7+bPXu2OnToULNwwWMco0ePVqdOncr/fMEhkUgkljd8KlI6NwdUKpU2DQP/zDFDhw7Vu+++W/7n4UGJRCKxvGGpSumqnNHs2bMD/zZnzpzya7pLly5auHCh3nnnnfDrec6cOTV7ulXR1NQUHHdVvPzyy2pubg68nxQlW5RbeRIak98oC5o8eXKpfXtzcsZMMfN/MOis4kKn87jkmckPcst3/377779/qclfuSyLnDqlQHxvKUoMf/3rX5ea+6FJkdNmItxf/vKXUrvkizIo/h2vi587OWdyv1KUyfE7kZ91WSNfwzlGiZ0Ux5L8p3PYXLv42c9+VmquVUhx3z/KHMl5kn+W4tzjhgQu+aLjjfPGA/HJlfK7kwOntM/PYZdddim1r33st99+pebGDtx/UYquPgoJTjvttHAcuW9uUEE5KzdbkCJ3Tk7dOXpy4mPGjCk11w+keG/wecEfjpzTUrzPKD3kNZI+4e99HaUtLNVfzt26dVOXLl2CbXjhwoWaOXNmmRhbbLGF2rdvH45566239POf/7zNh3MikUisaPhf/3J+7733wr8Ib7zxhl566SV99rOf1brrrqtBgwZp1KhR6t69u7p3765Ro0aptbW1qB46deqko446SqeeeqpWX311ffazn9Vpp52mjTfeuGY33kQikVhR8b8O23/iiSdCKHYVhx12mK677jpVKhWdf/75uuqqq/TOO++oZ8+emjhxYgh++eCDD3T66adr6tSpmj9/vnbYYQddccUV//RCXzVsf/LkyWptba2RyFEeQ7eT78PG/czYwlD+xYByKdIVbIs95JyhJ2yxKFuTYtvJ1uuxxx4rNSkEPwd+P78ubPv5uR5gz5aZkkI6qaTY8pH+4LX1PRIpNyTV5XsuchGZIT++SEx3I2VebDU9XOoHP/hBqUl5bLPNNuE4SqdIN7FVlSKtQUkb966UIu1FRyRrb5FJUXA++HoMZXq8hRluJEWJJx14HCOXp3E+kOqhZFKKdANpEv+RRakZqRFKAKV43zFQirSBbzrAuczPOfLII8NxNMvR2euUFSk+SmA5Dquvvnp4DelZmul4LaVPXJQLFizQpZde+g/D9v/Xv5x79+5dkyhGtGvXTsOHDw+WTUdzc7PGjx9fs8NHIpFIJD5GBh8lEolEHaKh9xAcOXKkmpubaxw3pAroVvL9wriaTkcR211v0+lCoorCV4effvrpUo8dO7bUV111VTiOCga6Aqkw8H0C2Q4yUIf0ghQzpakyYcCPJP3kJz9ZbO0KGaoR2C6zlWZWsRTpC7o/fcWalAkpBe59KEnf+973FnuuzOF1VQ4/lwE9DEGSonOSRieqUaToGGTL7RQYQ7I4J0lFOdiaL4l6INVFyoN7FUpR9UDlEdtpN3/x/Eg3+Xlzv8PRo0cv9nwkafvtty81XZlOKZAmofpp9913L7UrcUivkerhPoFSzAEn/ecU2I033lhqUnIcIxcucL6RMvE85yr1M3/+fA0ZMiT3EEwkEolGRD6cE4lEog6RD+dEIpGoQzR02P7qq6+ulpaWkEInxdBtSnc8V5r8FeVb9957b6mPOuqo8Jpbb7211JQmPfHEE+E48szkthng7e9BGRu5R/LcUnQ1ccMA35ON8j5ya9yAQIpcNXnSO+64IxxHjpGOPsqZPBmvd+/epWYKmat5yIdyDeGaa64Jx1FeRvkWZU+eEEhdPjl+5/L5PciJ+3GcN5xrTFKT4ljy70444YRSkzeX4nzleLvsjONCTp3cthQ5aDoT+V3551KUhlHS6WsQlASecsoppXapGflezmvys1J0I5L/J//sqYd0CHIzAV934L3AdQuX/Q0ePLjU55xzTql5nb///e+H1wwbNqzUfMZ4BHKVv/dzawv5yzmRSCTqEPlwTiQSiTpEQ0vpjjrqKHXo0CG0VFJsQ7mHHekFKbZEbJHZGnr4PzNB2Pr6tvGUMLGF5OulKPVjK+eOQ4Kfy9bSQ4coM2Ir5aFDDDOn1MlbvkcffbTUlFjRqef7zLEdp/PMZUaUOTL4yCWKv/nNbxb7WdxwgSFIkrT33nuXmpSVnyvli7xmDMiSYsgPW1efhy+88EKpKYVja046TYoOON6apAOkWtlkFaQhJOnss88uNWkvSsN8/0bOXdIxdDxKUcZJCoYUkxTpLMrluEeiFK9HW9fJQ/QZskSHMekvfx3vb994gvOVTmM6VX1TBd53lBvyO0ifSPjmz5+vM844I6V0iUQi0YjIh3MikUjUIRparfHee++pQ4cONW3U888/X2rSEp5by6CbZ599ttTcI9FpjTPOOKPUbJXcuUQKgO0gV6Sl2PpW912UYoiO5wTTsUY6xoN3mJfLFstzeY8//vhSUzXhGdV77rlnqUnP7LrrrqX2LcSoFmC77DnNt9xyS6m5Mu475tBVxmAZ0gYcEymG3jC8x1vKhx56qNSHHXZYqZ0mIa1E+onZzlKkLNj2Myfb5wPdm7xmJ554YjiO34nz3915bLOpKOIcZ3a1JN19992lJl3ke3Wy1eccd2qF9MyQIUNKTfpKiuFcvDdJK910003hNRxj3o9Oa5Ci4P3EoCIpOgt5HOeKz3Hupcix9Kzo6jxaJnnOiUQikVg6yIdzIpFI1CEamtY48MAD1bFjx5pVX67actWd7YcU2wu20jSakGqQolqAIT+XXXZZOI5hL2zRaDqR4go6V/EZyuMr9VRUMGvYxe0U+VP14KYd0j00l3BrJSmaO0h/sA121QrbSbb9nmNMIwRVE0899VSb78fvS+MDFTBSbMd5Dm7Y4Ko71QyekUxVBt/DzSqkG5glzpAmfw2vGc/b228aa9jCUzkjxW2wGNR18803l5p0lRTHgUoOp7lIyTAgjPeSFOc/KQ6nlXjuHC9uX+V0RVvZ36TJpEg/nXrqqaWmIUiK84imMH4H5qlLKhuJSJHu823QqvPa535byF/OiUQiUYfIh3MikUjUIfLhnEgkEnWIhnYIDhgwQE1NTTWB7NwzjhyVS1jIa1F+xUB2D5yZOnVqqSnd8X3+yE2Tg/PgdvKZlOORl3J5FP/7lVdeKbV/PwYmkSfzUHhyt3T+OddKLpJ8IXk65/o4/nRr0r0oxb0BKWHy8HiGIlF6RX7cnY3cPIGOymuvvTYcR3kZ1wY8uJ3jwPH3PQkZxMO5wnPwa8aQIMosDzzwwHAcnW1cV3GZJGVo5Kk5duutt154Dc+prb0KJemee+5Z7Gucx+VncdMHv7c453n/MEzokEMOCa/h/KJbk4FgUrwHOQ777bdfOI6bQ3Dtg+tVvk7AzQA4Dh7SVJWBzp8/X/3790+HYCKRSDQi8uGcSCQSdYiGltJ16dJFzc3NNW0Z3Vhs+SglkqLTh+0p5VruSKK8ie9NCZoUs3zZ1rmMjRm5lKHR7ecOLgY20UHn0jD+N1tuZk1LMUSHTjs/V44zaZIrrrii1KSKpNj6ssVmGJEUW1ru0cewJClSMpTzsf12GoiBV/x+nrdLCSaDme67775w3L777ltqficff547x5KuPc8+5nWnVNPnFyVblIa53I1zlC006RN3so0cObLUlNL5fOA4k14gNSBFGuGYY44ptTsJ6RhkrjLvH6cBrrzyylLTqTpw4MBwXP/+/UtNioNOXilSgTxv7hXp8tpp06Yt9u88V7xKtfD7LAn5yzmRSCTqEPlwTiQSiTpEQ6s1TjvtNDU1NdWs+tI1xJZjSfnEpBe49bm75NpyJNGpJ7XtWKPbSYohTZMmTSo1XYqe3csVebbIDGWSYpAPV7x9hZpjRJrEnWPMMd5jjz1KTSrDW1WueNMN6W5GUgqkjnzrLVI/dODRYUi1jRTbXY6dB+9QSbPllluWmsFQUtymiOFEBx10UDiO15Z0Cltzz3OmQobuSAY2SZHqopPNKR2OMxUQzFimQkeK7TjPxx8VnJekgbyd79mzZ6k5Xq5cIjVCeoHqFp+TDICiOoKvkeL8IEXE+0eKNA6pSV5zBm5JkV4jLeWhadVnwvvvv6/ddtst1RqJRCLRiMiHcyKRSNQh8uGcSCQSdYiGltL16NFDra2tQfomRTkRJWSecEbuiPwlE8l8zzI61MgfM0VOii4ycqAMnJeiJI2h7uuvv36pKenx96ZskPvPSZHrJqfuzj+eO9O3nBdmGhtTzXr37l1q35ePjqmddtqp1L5BArl98oVM95NiQh+vOyV27uBiChz5UHfTUS7F9zjnnHPCcX/6059KTYmWSxQvueSSUt9www2lJs/pKXJ0BVL66deC50Cu1vlQ8sT8XM5DXyfgegl5ZZeA8drSRenOOHKylOn5XpaUHlJOyXUQd4weeeSRpR4/fnypKTeV4nWnJJCvl+L8oouV6yA+d7n/JT/HN+Co3jMZtp9IJBINjIb85Vz9NVDNP/BfzjQ00Gjg/2Lx7/irgMfxlzI/01/jGa1cNef7+bnylyo/i6/xXyz8FcXas6LbyqHw43juPB9fyW7ru/OXiI8Dz4Hvt6RzIPwceFxb38mzQ/hrhu/n84Hnys/xOcBry+/u14mfy/db0nvzPZhF4uNF8NexqzX4d/xcvp+PQ1vH+ffjXOZruJWYFM1evDb+3TmX27offZ5wjJd0HE03PIclzS9+d/65jxfnAL+Tm3aqr6v+/z8SyjWklO73v/99kF4lEolEo+HNN9+s2ZyCaMiH80cffaQ//vGPqlQqWnfddfXmm28uUS+4vGPu3LlaZ511chxyHCTlOFRRr+NQqVT0t7/9TV27dg3dkaMhaY2VVlpJn/vc50q79JnPfKauBn9ZIcfhY+Q4fIwch49Rj+Pgi6aLQy4IJhKJRB0iH86JRCJRh2joh3NTU5POO++8oOFdEZHj8DFyHD5GjsPHaPRxaMgFwUQikVje0dC/nBOJRGJ5RT6cE4lEog6RD+dEIpGoQ+TDOZFIJOoQDftwvuKKK9StWzc1Nzdriy22qEmcW94wevRobbnlllpttdW05ppraq+99go7W0gfO4+GDx+url27qqWlRb179w47oCyPGD16tNq1a6dBgwaVP1tRxuEPf/iDDjnkEK2++upqbW3VpptuGnZfWRHG4e9//7vOPvtsdevWTS0tLVp//fU1YsSIkPvRsONQaUBMnz690r59+8rVV19d+eUvf1kZOHBgpWPHjpXf/e53y/rUPjXsvPPOlWuvvbby85//vPLSSy9V+vbtW1l33XUr7733Xjnmoosuqqy22mqV22+/vfLKK69UDjjggMpaa61VmTt37jI8808Pzz33XOXzn/98ZZNNNqkMHDiw/PmKMA5/+ctfKuutt17l8MMPr/zkJz+pvPHGG5VHH3208tprr5VjVoRxuPDCCyurr7565b777qu88cYblVtvvbWy6qqrVsaNG1eOadRxaMiH81ZbbVU57rjjwp9tsMEGlTPPPHMZndG/HnPmzKlIqsycObNSqVQqH330UaVLly6Viy66qBzzwQcfVDp16lSZNGnSsjrNTw1/+9vfKt27d6888sgjlV69epWH84oyDkOGDKlst912bf79ijIOffv2rRx55JHhz/bZZ5/KIYccUqlUGnscGo7WWLhwoZ5//vkQ3C59HOTOkPzlHdUNQz/72c9K+ji0ffbs2WFcmpqa1KtXr+VyXE444QT17du3ZtPeFWUc7rnnHvXo0UP777+/1lxzTW222Wa6+uqry9+vKOOw3XbbacaMGWVDi5/97Gd6+umny6a+jTwODRd89Pbbb+vDDz+s2TG4c+fOYTfs5RmVSkWDBw/WdtttV3aqqH73xY3L7373u3/5OX6amD59ul544QXNmjWr5u9WlHF4/fXXdeWVV2rw4ME666yz9Nxzz+nkk09WU1OTDj300BVmHIYMGaJ3331XG2ywgVZeeWV9+OGHGjlyZNkJvZHHoeEezlUsLlTc/2x5xYknnqiXX35ZTz/9dM3fLe/j8uabb2rgwIF6+OGHwzZOjuV9HD766CP16NFDo0aNkiRtttlm+sUvfqErr7xShx56aDlueR+Hm2++WVOmTNHUqVP1la98RS+99JIGDRqkrl276rDDDivHNeI4NBytscYaa2jllVeu+ZU8Z86cmn8dl0ecdNJJuueee/T444+HoO4uXbpI0nI/Ls8//7zmzJmjLbbYQqussopWWWUVzZw5U9/73ve0yiqrlO+6vI/DWmutFfbmk6QNN9yw7EO5osyH008/XWeeeaYOPPBAbbzxxurXr59OOeUUjR49WlJjj0PDPZw7dOigLbbYQo888kj480ceeURf+9rXltFZffqoVCo68cQTdccdd+ixxx6r2Xi2W7du6tKlSxiXhQsXaubMmcvVuOywww565ZVX9NJLL5X/9ejRQwcffLBeeuklrb/++ivEOGy77bY1UspXX31V6623nqQVZz7MmzevJrB+5ZVXLlK6hh6HZbgY+f8bVSndNddcU/nlL39ZGTRoUKVjx46V3/72t8v61D41HH/88ZVOnTpVnnjiicpbb71V/jdv3rxyzEUXXVTp1KlT5Y477qi88sorlYMOOqghJEP/V1CtUamsGOPw3HPPVVZZZZXKyJEjK//5n/9Zuemmmyqtra2VKVOmlGNWhHE47LDDKmuvvXaR0t1xxx2VNdZYo3LGGWeUYxp1HBry4VypVCoTJ06srLfeepUOHTpUNt988yIpW14habH/u/baa8sxH330UeW8886rdOnSpdLU1FT5+te/XnnllVeW3Un/i+AP5xVlHO69997KRhttVGlqaqpssMEGlcmTJ4e/XxHGYe7cuZWBAwdW1l133Upzc3Nl/fXXrwwbNqyyYMGCckyjjkNGhiYSiUQdouE450QikVgRkA/nRCKRqEPkwzmRSCTqEPlwTiQSiTpEPpwTiUSiDpEP50QikahD5MM5kUgk6hD5cE4kEok6RD6cE4lEog6RD+dEIpGoQ+TDOZFIJOoQ+XBOJBKJOsT/BxhvvUSf22OgAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([13])\n", - "original input image 9\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "original input image predict label 9 - predict label: 13\n", - "Attack completed at 1 iterations\n", - "tensor([9])\n", - "inverted image 9\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for cl in range(10):\n", - " mi_face(softmax_reg, cl)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/2-ml-models-attacks/checkpoints/mlp_mia.pt b/2-ml-models-attacks/checkpoints/mlp_mia.pt deleted file mode 100644 index 3adf336..0000000 --- a/2-ml-models-attacks/checkpoints/mlp_mia.pt +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:61d1dc377c55cbd54324e8a6f674606157aefeddc406555ba647c2d3296ccd5d -size 124141599 diff --git a/2-ml-models-attacks/checkpoints/softmax_mia.pt b/2-ml-models-attacks/checkpoints/softmax_mia.pt deleted file mode 100644 index 368e280..0000000 --- a/2-ml-models-attacks/checkpoints/softmax_mia.pt +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:87e2b8e0ef563c460d65e344af94d35cff57bf278ee21cd3b5a3bde72006f281 -size 1649911 diff --git a/2-ml-models-attacks/checkpoints/softmax_reg_opacus_test.pt b/2-ml-models-attacks/checkpoints/softmax_reg_opacus_test.pt deleted file mode 100644 index efe5ff2..0000000 --- a/2-ml-models-attacks/checkpoints/softmax_reg_opacus_test.pt +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:00dcda7366e33305003b1b5335ef864e5953816e86f83371be87a6d4792ee2a7 -size 1650087