Upload 8 files

visualization/Adversarial_Images.ipynb

@@ -0,0 +1,467 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Adversarial_Images.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.7.4"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9qk1zJDcAPyb",
+        "outputId": "f0d471cb-907c-45ee-acf6-0aa3f5e8d48e"
+      },
+      "source": [
+        "!pip install -qq -e git+http://github.com/tensorflow/cleverhans.git#egg=cleverhans\n",
+        "import sys\n",
+        "sys.path.append('/content/src/cleverhans')\n",
+        "import cleverhans"
+      ],
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "\u001b[?25l\r\u001b[K     |██▏                             | 10kB 22.7MB/s eta 0:00:01\r\u001b[K     |████▎                           | 20kB 29.3MB/s eta 0:00:01\r\u001b[K     |██████▍                         | 30kB 15.2MB/s eta 0:00:01\r\u001b[K     |████████▌                       | 40kB 11.1MB/s eta 0:00:01\r\u001b[K     |██████████▋                     | 51kB 6.6MB/s eta 0:00:01\r\u001b[K     |████████████▊                   | 61kB 7.0MB/s eta 0:00:01\r\u001b[K     |██████████████▉                 | 71kB 7.6MB/s eta 0:00:01\r\u001b[K     |█████████████████               | 81kB 7.9MB/s eta 0:00:01\r\u001b[K     |███████████████████             | 92kB 8.2MB/s eta 0:00:01\r\u001b[K     |█████████████████████▏          | 102kB 8.9MB/s eta 0:00:01\r\u001b[K     |███████████████████████▎        | 112kB 8.9MB/s eta 0:00:01\r\u001b[K     |█████████████████████████▍      | 122kB 8.9MB/s eta 0:00:01\r\u001b[K     |███████████████████████████▌    | 133kB 8.9MB/s eta 0:00:01\r\u001b[K     |█████████████████████████████▋  | 143kB 8.9MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████▊| 153kB 8.9MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 163kB 8.9MB/s \n",
+            "\u001b[?25h\u001b[?25l\r\u001b[K     |████████                        | 10kB 31.3MB/s eta 0:00:01\r\u001b[K     |███████████████▉                | 20kB 36.4MB/s eta 0:00:01\r\u001b[K     |███████████████████████▊        | 30kB 41.1MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████▊| 40kB 31.1MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 51kB 8.5MB/s \n",
+            "\u001b[?25h"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5R0e78sXAoFl",
+        "outputId": "e3716b0c-75e4-420e-b509-f14e37ec7785"
+      },
+      "source": [
+        "import tensorflow as tf\n",
+        "from cleverhans.future.tf2.attacks import fast_gradient_method\n",
+        "from tensorflow.keras.optimizers import SGD\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from wresnet import WideResidualNetwork\n",
+        "\n",
+        "import gzip\n",
+        "import pickle\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "\n",
+        "print(\"\\nTensorflow Version: \" + tf.__version__)\n",
+        "\n",
+        "\n",
+        "# defined utility functions\n",
+        "from preprocessing import preprocessing_data"
+      ],
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Tensorflow Version: 2.4.0\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WHKax8HV4L1A",
+        "outputId": "3b493537-5f81-4b0a-8dcd-3d5346e6cb97"
+      },
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Mounted at /content/drive\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "h5LxRSkt3ozC"
+      },
+      "source": [
+        "!cp drive/MyDrive/adversarial_examples_parseval_net/data.pz sample_data/"
+      ],
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "R5LbimfDA7MR"
+      },
+      "source": [
+        "def read_data():\n",
+        "    with open(\"data.pz\", 'rb') as file_:\n",
+        "        with gzip.GzipFile(fileobj=file_) as gzf:\n",
+        "            data = pickle.load(gzf, encoding='latin1', fix_imports=True)\n",
+        "    return data\n",
+        "data = read_data()"
+      ],
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "eUQ-IwRpDXdZ"
+      },
+      "source": [
+        "generator = tf.keras.preprocessing.image.ImageDataGenerator(rotation_range=10,\n",
+        "                               width_shift_range=5./32,\n",
+        "                               height_shift_range=5./32,)"
+      ],
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "NjPPU_u2BE7J"
+      },
+      "source": [
+        "X, y = preprocessing_data(data)\n",
+        "X_train, X_test, Y_train, y_test = train_test_split(X, y, test_size = 0.1)\n",
+        "x_train, x_val, y_train, y_val = train_test_split(X_train, Y_train, test_size = 0.1)"
+      ],
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "CN6sQkhXBJoq"
+      },
+      "source": [
+        "EPOCHS = 50\n",
+        "BS = 64\n",
+        "init = (32, 32,1)\n",
+        "sgd = SGD(lr=0.1, momentum=0.9)\n",
+        "parameter = {'epochs': EPOCHS, 'batch_size': BS, 'optimizer': sgd}"
+      ],
+      "execution_count": 8,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "TM6hWyAHBLxG"
+      },
+      "source": [
+        "wresnet_ins = WideResidualNetwork(init, 0.0001, 0.9, nb_classes=4, N=2, k=1, dropout=0.0)"
+      ],
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "NA7I7ZXEBP6h"
+      },
+      "source": [
+        "model = wresnet_ins.create_wide_residual_network()\n",
+        "model.compile(loss=\"categorical_crossentropy\", optimizer=sgd, metrics=[\"acc\"])\n",
+        "model.fit(generator.flow(x_train, y_train, batch_size=BS),steps_per_epoch=len(x_train) // BS,\n",
+        "          validation_data=(x_val, y_val),epochs = EPOCHS,\n",
+        "          validation_steps=x_val.shape[0] // BS,)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "HFLFt-evCbuC"
+      },
+      "source": [
+        "import cv2\n",
+        "image = data[8] \n",
+        "img= cv2.resize(image['crop'], (32, 32))\n",
+        "\n",
+        "img = img.reshape(1, 32, 32, 1)"
+      ],
+      "execution_count": 66,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "qFjwgbBJIJin"
+      },
+      "source": [
+        "from sklearn.preprocessing import LabelEncoder\n",
+        "import pandas as pd\n",
+        "label_orginal = image['label']\n",
+        "label = y[8]"
+      ],
+      "execution_count": 67,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 35
+        },
+        "id": "K3ZihnSl8bnM",
+        "outputId": "5a00841b-88d6-44c8-c466-d3cb437fd3ca"
+      },
+      "source": [
+        "label_orginal"
+      ],
+      "execution_count": 84,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            },
+            "text/plain": [
+              "'open'"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 84
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "-S78HJ84Fe8Z"
+      },
+      "source": [
+        "def adversarial(model, img, label, epsilon):\n",
+        "    original_image = img\n",
+        "    original_image = tf.convert_to_tensor(original_image.reshape((1,32,32))) #The .reshape just gives it the proper form to input into the model, a batch of 1 a.k.a a tensor\n",
+        "    original_label = label\n",
+        "    original_label = np.reshape(np.argmax(original_label), (1,)).astype('int64')\n",
+        "    adv_example_targeted_label = fast_gradient_method(model, original_image, epsilon, np.inf,y=original_label, targeted=False)\n",
+        "    adv_example_targeted_label = np.array(adv_example_targeted_label).reshape(32,32)\n",
+        "    return adv_example_targeted_label"
+      ],
+      "execution_count": 68,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "XUqkTcDeD5Dp"
+      },
+      "source": [
+        "img_50 = adversarial(model,img, label,epsilon=0.003)\n",
+        "img_50 = (img_50 - img_50.min()) * 255 / (img_50.max() - img_50.min())\n",
+        "label_50 = np.argmax(model.predict(img_50.reshape(1,32,32)))\n",
+        "img_45 = adversarial(model,img, label,epsilon=0.005)\n",
+        "img_45 = (img_45 - img_45.min()) * 255 / (img_45.max() - img_45.min())\n",
+        "label_45 = np.argmax(model.predict(img_45.reshape(1,32,32)))\n",
+        "img_40 = adversarial(model,img, label,epsilon=0.01)\n",
+        "img_40 = (img_40 - img_40.min()) * 255 / (img_40.max() - img_40.min())\n",
+        "label_40 = np.argmax(model.predict(img_40.reshape(1,32,32)))\n",
+        "img_33 = adversarial(model,img, label,epsilon=0.02)\n",
+        "img_33 = (img_33 - img_33.min()) * 255 / (img_33.max() - img_33.min())\n",
+        "label_33 = np.argmax(model.predict(img_33.reshape(1,32,32)))"
+      ],
+      "execution_count": 85,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "y_gDte-XLW5e",
+        "outputId": "4e700ec9-9e9b-4f28-a0d9-4708ec0e3f07"
+      },
+      "source": [
+        "print(\"img_50: {0} \\n, img_45: {1}, img_40: {2}, img_33:{3}\".format(label_50,label_45,label_40, label_33))"
+      ],
+      "execution_count": 79,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "img_50: 1 \n",
+            ", img_45: 1, img_40: 1, img_33:1\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 281
+        },
+        "id": "ty7sB8dJGz2B",
+        "outputId": "a7403127-46e9-4e35-985a-361c4a5d5d05"
+      },
+      "source": [
+        "original_img = data[8]['crop']\n",
+        "label_orginal\n",
+        "recovered = (original_img - original_img.min()) * 255 / (original_img.max() - original_img.min())\n",
+        "plt.title(\"Image Label : {0}\".format(label_orginal))\n",
+        "plt.imshow(recovered, cmap='gray')\n",
+        "plt.savefig('Original.png')"
+      ],
+      "execution_count": 80,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 35
+        },
+        "id": "SY5LT50SHERi",
+        "outputId": "83ed36a9-575e-4117-915d-e3c04814cec5"
+      },
+      "source": [
+        "data[0]['label']"
+      ],
+      "execution_count": 72,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            },
+            "text/plain": [
+              "'open'"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 72
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 326
+        },
+        "id": "7E-AAdfkG3ty",
+        "outputId": "39efb788-1f0d-41e6-8b13-6ca78c367ea4"
+      },
+      "source": [
+        "plt.figure(1)\n",
+        "fig, _ = plt.subplots(2, 2)\n",
+        "fig.tight_layout()\n",
+        "\n",
+        "plt.subplot(221)\n",
+        "plt.title(\"SNR=50\")\n",
+        "plt.imshow(img_50,cmap='gray' )\n",
+        "plt.subplot(222)\n",
+        "plt.title(\"SNR=45\")\n",
+        "plt.imshow(img_45,cmap='gray' )\n",
+        "plt.subplot(223)\n",
+        "plt.title(\"SNR=40\")\n",
+        "plt.imshow(img_40, cmap='gray')\n",
+        "plt.subplot(224)\n",
+        "plt.title(\"SNR=33\")\n",
+        "plt.imshow(img_33, cmap='gray')\n",
+        "plt.savefig('PertubatedImagesforDifferentSNR.png')\n",
+        "plt.show()"
+      ],
+      "execution_count": 82,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 0 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV8AAAEkCAYAAACIUDKDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2de5Bd1XXmv0XTAiRAEhYIISEJ0BskBBIPEWIcP6aMyUQuG7viZBJweUxVZlyxY1cZBieOXcmkqHGVk5okk1gpe8AOMZDYVaYAx2EchO3wlIRAj0ZIAvRCQoAkQAL06jV/3HN3f3up7+2r7tv3XPX9flUq7b5nn8c9fb7dZ6291trm7hBCCNFaTir7AoQQohPR4CuEECWgwVcIIUpAg68QQpSABl8hhCgBDb5CCFECGnyFEKIEOmLwNbNrzewxM3vTzPaY2X+Y2RVmdrOZuZl9NfTfbmYfKNrfMLPDZrbfzPYVx1kyiGuYXpxrP/37E9p+ipl9z8zeMrNdZvblIX9xIZpMO2gpHP/rxXk/TJ/daWaHgta6hnKe4WDED75mdiaABwD8NYCzAEwG8E0AB4suewB81czOqHOYe939dAATADwC4J+HcEnj3P304t+f0effADATwDQAv1Fc00eHcB4hmkq7acnMLgLwKQA7+9n8v0hnp7v70cGeZ7gY8YMvgFkA4O4/dPej7v6uu/+buz9XbO8B8DiAAd803f0IgLsBTDazs5t8nTcB+DN33+vuPQD+AcDNTT6HEEOh3bT0twBuBXBokPuXSicMvi8AOGpmd5nZ9WY2vp8+fwLgS2Z2Vr0DmdkoAL8P4A0Ae4vPphYmVK1/vxMOs6Uwxf6vmU0ojjEewCQAz1K/ZwFcPKhvLMTw0DZaMrNPATjo7g/VOMV/K9wiK83sk4P5ssPNiB983f0tANcCcFTeJl8zs/vNbCL1WQ3gYVT+ivbHp81sH4B3AXwewI3FX264+1Z3H1fn3z8Vx3gdwBWouBUWATgDlb/8AHB68f+bdM43iz5CtAXtoqXCrfEXAL5Y4xz/GxUX3jmo/DG408x+bYhfv+mM+MEXANy9x91vdvcpAC4BcB6Avwrdvg7gD/hBIu5z93EAJgJYi8rgebzXsN/dV7j7EXd/FcAXAPyn4kHaX3Q7k3Y5E8Dbx3seIYaTdtASKvMjP3D3l2tc4yp3f6PQ2kOovOR8YhDnGVY6YvBl3P15AHei8uDEz38M4Gt19n0dwC0AvmFmk4BkKu2v8+93ax2u+P8kd9+LyqTBpbT9UgDrBvEVhWgJJWrpQwD+sIgK2gXgfAD3mVmtt20HYEP4qsPCyWVfwHBjZnMA3IDKLOt2MzsfwGcAPNFP928CeA51flHuvsHMfgbgqwD+yN23os9tUO86rgKwD8BGAONRMY2Wu3vV1fB9AH9sZitQeSv4PIDPNvYthRh+2kVLqAy+3fTz06hM8v20uM4bAfwrgHcAfBjAfwHwnxs4bkvphDfftwFcBeBJMzuAyoOyFsBXYkd3fwnADwCMGeCY3wJwi5mdcxzXcSEqD8TbxfkPovLgVvlTAJsBbAHwKIBvufu/HsfxhRhu2kJLhUthV/UfgKMA9rp71X33RQA7UHnZ+RaAz7v78kaP3ypMxdSFEKL1dMKbrxBCtB0afIUQogQ0+AohRAkMafA1s4+a2QYz22RmtzXrooToNKSlzmPQE25FlaAXAHwEwHZUwj0+4+7ra+0zevRoHzt2LACgt7c323bkyJF+9znppPzvw7vvvpvap5xySmofPZrXzeDjjRnTN+F6+PDhrB//zPci9uPrPfnkvgi9eH28n1keZcPXe/DgwdSO94L78TWdeuqpWT/+ma8j3ks+HhPvGZ9rx44dr7t7s+tXiH44Xi11uo5GjRqV2ocO9ZV1aFRHp512Ws1+rdTRUOJ8rwSwyd1fBAAzuwfAUgA1B9+xY8fis5+thK4eOHAg27Znz57U5pvNNxoAenp6UnvatGmpHY+3e/fu1L7iiitSe9euXVm/nTv7CiLxLzz248FywoQJqR0HRD5e/GXx9b700ks1r33WrFn9nnfu3LlZv5kzZ6Y2C+P111/P+s2YMSO1+cHYu3dv1o+//+23374FolUcl5ZaqaNXX3217yKvvDK1y9TR1KlTU/vll1+uee21dDRv3rysH+ujlToaitthMoBt9PP24rMMM7vFzFaY2Yp33nlnCKcTYsQyoJako5HHsGe4ufsyAMsAYNy4cb527VoAwOmn54ksr732WmqzScR/HYH8rzk/hOeck8do818m/gsW/5rxdXA7mib817b6HQDgvffey/pNmTIltbdu3Zpt6+rqq+d81ll9RZ/GjRuX9ePveO6556b2+PF5Eak33ngjtd98s68mT7xnfF7+qxzNqmg+ifahk3W0ZUv+8sjuisHoKPYrS0dDefPdgUpOdZUpxWdCiONDWupAhjL4Pg1gppldUNTm/G0A9zfnsoToKKSlDmTQbgd3P2JmXwDwMwBdAL7n7qrCJcRxIi11JkPy+Ra1MmtVkj+G7u5unHfeeQCAF154Ids2evTofvfZt29f9jPPuD7//POpzbOyANJ5gNz3E0Nf2P/Ds6XVUJ4q7L/lbdOnT8/6cRTD+eefn21j/9kZZ/TVSeeZWAC44IILUptnfefPn5/1e+WVV9AfvD+Q+7F45jj6tOKsrWgdx6Olejri2XrmRNYR+4mBxnXEx+Soi2br6H3ve1/WL97rWijDTQghSkCDrxBClEBLi6kfPXo0hXXEcA8OkZk9e3Zqx5hGfqW/5pprUjuGqrBJw+0Y9M1B2hx8vX59Ht/OIS1s9kQTgxMhOJAdyEPF2DSL2T0cSnP11Ven9ttv56sKcUgLn3f//v1Zv+7uvrrTHBYTzS0+r2hfjhw5kkK9Bqujt956K7VbqSN2dXFG2nDoiJ/7ejri65gzZ05qRx1xogrriF2DQOM60puvEEKUgAZfIYQogZa7HapmQjQR+HX/7LP76lDEV3jOMmETK87yXnpp31qUy5cvT+2rrroq68dm26ZNm1J7wYIFWb9Vq1alNps9kyfnGdXsnoimGZtBnHETc9f5+DzDzKYdkEeIcC2LiRPzRWM535/vH+f0A3mREtG+9Pb2JjdCWTriaAkg19HmzZtT+0TQEWfh8b2I2X6N6ihGXdRCb75CCFECGnyFEKIENPgKIUQJtNTna2bJV8K+GiD38XBmWPRDctYKV22KhZQ5/IP9Vs8991zW78wzz0xtDrl58cUXs36LFy9O7R07+mqexDqkfE0xDIhDV/h6YxUk9s+xXzcWvr/oootSO2YmMZyBw35t9lsBx9ZDFe1JO+hozZo1WT/W0ZIlS1JbOqqN3nyFEKIENPgKIUQJtNTtMHr0aCxatAhAXrADyM0MLsYcC3hwSNV1112X2hzeEo/BBWPYdAJyE4Gze2JoDhePvvjii1P7wQcfzPpxEZCYScNZMRwOFk0dNvXYJKq3VhSH2fA9AnKTjouFxLAiNqVE+9KojrjojHRUW0fsuqinI97WDB3pzVcIIUpAg68QQpRAS90OXV1dyRSKa09xBgpnprDpFOHCMHF5aS4kcuGFF6Z2zG7h9ZvYHIm1bnk2d/v27akda35yxlGsZcrH4FlgnqEG8owbNhfjrC9fBxf9iJk5kyZN6rffypUrs368OqtoXxrVET8v0lFtHfH35+y5weqIXRz10JuvEEKUgAZfIYQoAQ2+QghRAi31+Y4ZMyZVFYsFiNmfwv6pGMbBYSbsn2H/DpCH3HCoSqyexD4tPl7MgmG/EBd+jplD7I9iv1A8F2fLxGNwVSQOb4nXxPepGnoE5IWygTxEiK8h+tk2bNgA0f7U0xFnvDVDRxw2xjqKIW5l6Yj9vDGcriwdxXX1aqE3XyGEKAENvkIIUQItdTscPnw4FdOIRc25WAa7ICKcdcLmQiy4zOEpbMI8++yzWT8uilEvu4XDUzi8J5pEvLx0zO7hnznTJy7ZzqF2vC0W8OAwHjZ1YrEVDtth8y4WPYmmpGhPmqEjLhrOz3PUEWun2TpiV0gME2OTn90Y8VyN6ohdHO2iI735CiFECQw4+JrZ98xst5mtpc/OMrOHzWxj8f/4escQQkhLIqcRt8OdAP4GwPfps9sA/Nzd7zCz24qfbx3oQKNGjUoFM2ImzUsvvZTabHLwOlRAbkrwTG+sB8omCM/sxllfNos4QiKaHE899VRq18sWYhMpLj3N52bTJ5pcvI3dGDFbiPtxFEdcQ4rvJ3+vWLBky5YtEMPKnWiClrq7u7NavUyjOmLzv1EdcTRBM3TEbowIu+jic8pukkZ1xG4HjjSK/dhlECMwmq2jAd983f0XAPaEj5cCuKto3wXg4w2dTYgORloSzGB9vhPdvfrncheAibU6mtktZrbCzFZEh7gQojEtsY74LU6cuAx5ws0rEcteZ/syd1/s7ovZZSCEyKmnJdZRLAwjTkwGG2r2qplNcvedZjYJwO4B9yiohmtwpgsAzJs3L7XZZ7Rq1aqsH689xW8Ac+bMyfpxCMq2bdtSO1YcYt8z+7vi9XHBac5uefLJJ7N+7IuLFac4JIX9t6tXr876feADH0jtPXv6rNTo0+Jr5ApM0SfNVabYJ83rWgH5fRct47i1xGu4xQw31hH7/puhI65CdiLrKL4ENqojLrreDB0N9s33fgA3Fe2bAPxkkMcRotORljqURkLNfgjgcQCzzWy7mX0OwB0APmJmGwF8uPhZCFEHaUkwA7od3P0zNTZ96HhPdvTo0RS6EkPNOBSGX/ejGcRhIVdeeWVqP//88zX7sVkxZcqUrB/7z9h8iFk1nBHEYTDx+jisLZojDJtIMQyIzTE2YWLBjhtuuCG1+X7GwiH8Xdgk5Iwd4Nh7I5pLs7TUqI44HGzu3LlZP/7dX3HFFakdiys1qiPOKOXz1tMRX0MrdbRx48asX6M64ntRT0e1wgAjynATQogS0OArhBAl0NLCOkDfK3qcwVy/fn1q84xtzEbhmc7ly5endixmwUtKL126NLXZFAHy+qWcfXP11Vdn/WbNmpXay5YtS+04I8omV8w0Y7ON10uLRUpqhRJxbVUAqbgKkEdCxGI/PEvLx479+HiivTleHcVIGdbRo48+mtrSUW0dsRuino44KqQeevMVQogS0OArhBAloMFXCCFKoKU+35NPPjmFg8SCxhy6wSEjXKUJyMM6uJJX9LNwxaRalZmAvOA0Z+2w3wrI/Trsn+IMICD3hcUQFN6Pt8XqTs8991xqz549O7VjxSn25fL3itfEfkHOiIrF3mPYkmhPpKP+dRT9xrV0xMXegVxHHOI23DrSm68QQpSABl8hhCiBlrodent7ceDAAQB5CAuQFyrmQjjRJOdQEDYLOKwGQDoPkIeWxNAcPhdnkMUCyXwuLpIes2XY7IsFp9ksYtMnhsRwAXW+3mgucUEUPkY0CdmU4n042wg41nwS7UlZOuIssagjdlc0qiM+dszeHIyOYsEcvhf1dMTulFbqSG++QghRAhp8hRCiBFpqZ44aNSoV5Iiv6m+88UZqX3LJJakdq/bzzCTXqY3ZLZz5wubD2rVrs35smj3zzDP9Hjse/9VXX0Ut+Htcfvnl2TYuEMKz1PPnz8/6sXm3Zs2a1I6zuTyDy8TZVp5hrrX+FXBsbVjRnjRbR2xO19MR91u3bl3Wbzh1tGjRomwbZ9M1qiPWfXSZsI44iy3qiIsENUNHevMVQogS0OArhBAloMFXCCFKoKU+3/379+OJJ54AcOwaUOzH2bVrV2rHrC4OH2Ef6qFDh7J+DzzwQGpzGAyHcQG5T3Xz5s2pfdlll2X9OBSGQ1OmTp2a9ePr+MUvfpFt4+/MBZeffvrprB9Xcov+KYb9afXWjeLQF75nsdJVo9WYRLk0W0e8Tz0dcfWv6EMeTh1x1TVgcDqK4WoM+3ljxTOGfb58vMHqSG++QghRAhp8hRCiBFrqdujq6kqv6zHzhTNLOBwlZtysWLEitS+44ILUjus8sYn0+OOPpzabREBukrOJv2DBgprnZWLxDQ47iWtAsRnI1xszczgEh6+jp6en5rVzeEvM4GGziIttxxCZ+DsR7clJJ52Unp9m6yia56yjxx57LLU3bdqU9asVzjgcOmJ9NENHXJynlTrSm68QQpSABl8hhCgBDb5CCFECLfX5untKUeRQFwB4+eWXU3vmzJmpvXXr1qxfrYpivCAgkPtX+Rhjx47N+nEa4+7du1P73nvvrdmPqbeQYISvndsxHfHGG29MbfZHxTRL9i1xumgk+q6qxNTPescQ7UX1d1eWjmIlPtYHX1PU0Z49e9Afx6Mjfu75e/C1AsAnP/nJ1Ga/bKM6inpgHbEfmtOu+9uvFnrzFUKIEhhw8DWz883sETNbb2brzOyLxednmdnDZrax+H/8QMcSopORlgTTiNvhCICvuPsqMzsDwEozexjAzQB+7u53mNltAG4DcGu9A5lZenWPGTLsDvjVr36V2uedd17WL5pZVdjcAvJqT5xlE80ldjWw2cIZO0Ae1sXZN7HyEWfIxLWnOByHTbiFCxdm/X7wgx+k9nXXXVfzXJxxU61yBRxbOPuVV15JbV7XK4b3xKppouk0RUsnso7Y/Ge3VyfqaMA3X3ff6e6rivbbAHoATAawFMBdRbe7AHy8oTMK0aFIS4I5Lp+vmU0HcBmAJwFMdPfqTNEuABNr7HOLma0wsxWxroIQncrxakk6Gnk0HO1gZqcD+BGAL7n7W/zq7u5uZt7ffu6+DMAyAJg8ebKvWrUKQP56D+QZI3zsaLawyc8m0Zw5c7J+XEiETbFYqIZNGjY/4mwrF4tmk23u3LlZvzhbzPD3OnjwYM1+PBvLxUFi5sy5556b2mz2xXvLsDlXb8ZaDB+D0VLU0erVqwEc605olY6iaT1SdMRZcY3qKGbWRTdELRp68zWzblQelrvd/cfV6zSzScX2SQB219pfCFFBWhJVGol2MADfBdDj7t+mTfcDuKlo3wTgJ82/PCFGDtKSYBpxO/wagN8DsMbMVhef3Q7gDgD3mdnnAGwB8OnhuUQhRgzSkkgMOPi6+68AWI3NHzqek/X29qaMlJiNwqFcL730UmpzxSUg96ccOHAgtWNloQsvvLDfa4iZNOz/4WNEHxRvY59WDNnhMJjoC6pVQS36xfia+PgxRIb9vOyD46wfIPfjsa8q3otYGU40l2Zpqbe3Nz0XMQyLn032mzZDR5y5FYuON1tHnE0WdcTHaEcd1cvOY5ThJoQQJaDBVwghSqClhXVGjRqVzBh2LQC5ecNmUAwN4zWbuEhHNYStCpsqbJpFM43NDDYfYrgIuxMmTJiQ2mw6AXkx6rhuFpsqfLxY4IYza9j04UIpcRuHxUQziDNz2PURC+7E9btEe9Kojvj5aIaO+FmPz4p01EejOtKbrxBClIAGXyGEKIGWux2qGTnRzOCUSTaJopuAs3EmTuzLwrz++uuzfhxNwZlc0Qxi04TNilijk00frn/K1wrks6qHDx/OtrGpwt8r1v/ktaLYlIpmFZttfP/4PEBuinIGD+8PAGvXroVof+rpiAvtnEg6itlkHKlQT0cc+RB1xC4T3tYuOtKbrxBClIAGXyGEKAENvkIIUQIt9fky0VfF/iT2R02aNCnrx2sncYhIzMzZtGlTav/Wb/1WasewFT4+h7fECl+c/cW+oOgX2r59e2rHEBTOOOJtMbOMw3b4+NF/xtu4MhNXcAJyHxfvE9fTWrBgAcSJRdQR+zkb1RH7V+Pz3KiO+PlrpY441Gy4dcT7NUNHevMVQogS0OArhBAl0FK3Q1dXV3IvxILGbBZx6EssgsFhJ2xmxGIWbBZVC08DxxZf5gLRnFnH5kf12vs7xjPPPJP1u/zyy1ObTTYg/4587bEwNZuLnGUze/bsrB8XBGHTbMuWLVk/Np9+/dd/PbVXrlyZ9atXmFq0D43qKD7DzImko82bN2fbGtVRreXsm62jFStWZP0a1ZHefIUQogQ0+AohRAm01O1w6qmnpvqe7FoAgEcffTS12eSIs6A8m8sZMjHagd0VM2bMSO24NPaGDRtSm02OWF+UM1/YrIprXnGhk/gd9+7dm9o8cxpNR85S4pnjCJs3vJbXu+++m/XjoirPPvtsaseZ6HivRXvSjjp64YUXUpsjEBrVUaz7yzo655xzsm2sI3afRB1xFEK9WtVD1VGMdmhUR3rzFUKIEtDgK4QQJaDBVwghSqClTj5ewy0WKuaqRlyBiTPfgNxnxP2ib4nDQtgnc/bZZ2f9uDoTb+OqRUDuh2UfFFdzAvKwFfZpAXkRaA4ni+E48+bNS+2Y3cPEakpVYvYRF3fmMJ147bEqlGhPGtUR+2sHqyOusMe+1uHWEe/Xjjpi3/BgdaQ3XyGEKAENvkIIUQItdTscOnQI27ZtA3Ds0u4cxsHtaHJMmzYttTlEJi6NzRkz06dPT+2YLcNhIWxyxUIkHNLDrgU+NpCHb3E/IDdP2DyMGTG1Cp3Ec3HRajbT6i21XSsTCdAabicKw6mjeDxe062VOmJXYXRdDKeO2I1RT0d8DYPVkd58hRCiBAYcfM3sVDN7ysyeNbN1ZvbN4vMLzOxJM9tkZvea2aiBjiVEJyMtCaYRt8NBAB909/1m1g3gV2b2UwBfBvCX7n6Pmf09gM8B+Lt6BxozZgwWL14MAFi3bl22jc0gnomNpvusWbNSe8mSJanNM7FAPkvLM8LR5GC2bt1acxubGTt27EjtOFPKM72xHihnxbA5FuuLsguFv39PT0/Wj9foqjV7DeTmF88Uc01XoPasr2gaTdFSJ+iIf+ZrAHKX4nDqKNJsHQ345usVqlXLu4t/DuCDAP6l+PwuAB9v6IxCdCjSkmAa8vmaWZeZrQawG8DDADYD2Ofu1T812wFMrrHvLWa2wsxWsDNbiE5ksFqSjkYeDQ2+7n7U3RcCmALgSgBzBtiF913m7ovdfXEMzBai0xislqSjkcdxhZq5+z4zewTAEgDjzOzk4i/2FAA76u9d8Y1Usz8WLVqUbeP12Ni3Ev2m7O+ZOXNmascKXRxSxf6ZnTt3Zv3YPzN5ct8LR8yIYX/S/PnzUzu+hXB1Jg5hAfIMHC78HCuXsX9q4cKFqR19aeyf4myhGCLDVaa4wPvUqVOzfjFkRgwfQ9FSM3TEhdG5Wlk76oh9w0Du5x2Mjnh9OKA8HTUS7XC2mY0r2qcB+AiAHgCPALix6HYTgJ80dEYhOhRpSTCNvPlOAnCXmXWhMljf5+4PmNl6APeY2Z8DeAbAd4fxOoUYCUhLImExTGJYT2b2GoADAF4fqG+HMAHtey+mubuci21IoaMtaO/np9W0672oqaOWDr4AYGYr3H1xS0/apuheiKGg56ePE/FeKL1YCCFKQIOvEEKUQBmD77ISztmu6F6IoaDnp48T7l603OcrhBBCbgchhCgFDb5CCFECLR18zeyjZrahqFt6WyvPXTZmdr6ZPWJm64tarl8sPj/LzB42s43F/+MHOpYQnaqlkaSjlvl8i6yeF1BJqdwO4GkAn3H39S25gJIxs0kAJrn7KjM7A8BKVEoH3gxgj7vfUYhovLvfWuKlijank7U0knTUyjffKwFscvcX3f0QgHsALG3h+UvF3Xe6+6qi/TYqOf2TUbkHdxXdVMtVNELHamkk6aiVg+9kANvo55o1gEc6ZjYdwGUAngQw0d2rJaJ2AZhYYzchqkhLOPF1pAm3FmNmpwP4EYAvuftbvM0rPiDF/gkxACNBR60cfHcAOJ9+bqgG8EiiWLfrRwDudvcfFx+/Wvixqv6s3bX2F6Kgo7U0UnTUysH3aQAzi5VaRwH4bQD3t/D8pWJmhkqpwB53/zZtuh+VGq6AarmKxuhYLY0kHbW6pOTHAPwVgC4A33P3/9myk5eMmV0L4JcA1gDoLT6+HRV/1X0ApqJSJvDT7r6nlIsUJwydqqWRpCOlFwshRAlowk0IIUqgIwZfM7vWzB4zszfNbI+Z/YeZXWFmN5uZm9lXQ//tZvaBov0NMztsZvvNbF9xnCVDvJ6vF+f9MH12ipl9z8zeMrNdZvbloZxDiOGgHbRkZvPMbIWZ7S3+/T8zm0fb/8jMXiy09IqZ/aWZHddiwa1gxA++ZnYmgAcA/DWAs1CJh/wmgINFlz0Avlpky9TiXnc/HZWlSh4B8M9DuJ6LAHwKwM6w6RsAZgKYBuA3imv66GDPI0SzaSMtvYLKgqNnFce5H5VEkyr3A7jc3c8EcAmASwH84SDOM6yM+MEXwCwAcPcfuvtRd3/X3f/N3Z8rtvcAeBzAgG+axdLedwOYbGaDXd/sbwHcCuBQ+PwmAH/m7nvdvQfAP6CSMilEu9AWWnL3fe7+chHPawCOAphB2ze7+77iR0NlYm7GsUcql04YfF8AcNTM7jKz62sU3PgTAF8ys7PqHagI6/l9AG8A2Ft8NrUwoWr9+x3a/1MADrr7Q+G441FZ2fZZ+vhZABcP4vsKMVy0jZaK/vsAvIfKm/hfhG2/Y2ZvobKo5qUAvjO4rzx8jPjBt8h+uRaVjJd/APCamd1vZhOpz2oAD6PyRtofny5+0e8C+DyAG4u/3HD3re4+rs6/fwKAwhT7CwBf7Of4pxf/v0mfvQmgnvkmREtpFy3RucYBGAvgCwCeCdv+qXA7zALw9wBeHfodaC4jfvAFAHfvcfeb3X0KKj6g81CJkWS+DuAP+EEi7it+0RMBrAWwaBCX8Q0AP3D3l/vZtr/4/0z67EwAbw/iPEIMG22iJb6eA6gMrt83s3P62b4RwDoA/2co5xkOOmLwZdz9eQB3ovLgxM9/DOBrdfZ9HcAtAL5BqYxTi9nbWv9+t9j9QwD+sIhk2IVKeuh9Znaru+9FZQLuUjrdpag8NEK0JSVqKXISgNGoXVzoZAAXHc93awVtF37RbMxsDoAbUJll3W5m5wP4DIAn+un+TQDPoeKk7xd332BmPwPwVQB/5O5b0ec2qMeHAHTTz0+jMjHx0+Ln7wP4YzNbgcpbwecBfLaB4wrREtpFS2b2EVR8uc8BGAPgz1HxG/cU2/8rgPvdfXcRgvY/APys4S/aIjrhzfdtAFcBePbkj50AAB0gSURBVNLMDqDyoKwF8JXY0d1fAvADVH6h9fgWgFv6M3Nq4e5vuPuu6j9UZmj3unvV5fCnADajkhr5KIBvufu/Nnp8IVpAW2gJwDgAP0RlXmQzKm+1H3X394rtvwZgTXGNDxX/bj+O47cEpRcLIUQJdMKbrxBCtB0afIUQogSGNPhah66gKkSzkZY6j0H7fK2DV1AVoplIS53JUELN0gqqAGBm1RVUaz4wo0eP9rFjxwIAent7s21HjhxJbTPrtw0A7777bmqfcsopqX306NGaxxszpm/C9fDhw1k//pn/EMV+fL0nn9x32046KTceeL947aNGjUrtQ4f6SjvEe3Hqqaf2u+20007L+vH35+vg7x77MfGe8fffsWPH6+4+2PoV4vg4Li1JR+2tIz7XK6+8UlNHQxl8+1tB9ap6O4wdOxaf/WwldPXAgQPZtjfeeCO1u7q6Uru7uzvrt25dX97BBRdckNrxeK++2pdNeNVVfZe1c2deTIx/5l/4rl27sn4HDx5M7QkTJqQ2/4Lj8eIva+rUqan98ssv17z22bNnp/Z7772X2vPmzcv6zZjRVytk9OjRqc33MvZjYezduzfrx9//9ttv3wLRKo5LS6yj/fv3Z9v27OlbvIF1xAMWAKxduza1h1NHvD+QP8+sI35+AWDHjr4l6ZqhIx6k586dm/W78MILU5v/wEQdXXRRX54G62jfvn1ZPz7X1772tZo6GvYJNzO7pai9ueKdd94Z7tMJMSKRjkYeQ3nzbWgFVXdfBmAZAIwbN87XrFkDADj99DyR5bXXXkttfst83/vel/Vjs4AfwnPOyWO0+S8TH/v111/P+vF1nHFGXx2b+Jf4/PP7viq/ffNfcgCYMmVKam/Zkv/RYzOLv9e4ceNQi3PPPTe1q6ZmFf7L/OabfTV54j3jNyD+qxzNpfizaBkDammoOuK3TCDXEbsgJk7MyzGwjnbv7lsQOOqI3xjPPLOvREnUEetj/fo+r0rUEeuN326B3BrmZz3qg78jjw98fUBuAb79dl85lbPOyguzsY747b6e26EeQ3nz7dgVVIVoMtJSBzLoN193P2JmX0AlZ7q6gqoKwQhxnEhLncmQCusURcEfGrCjEKIu0lLn0dKqZt3d3TjvvPMAABs3bsy2sc+IQ0viTCLPuD7//POpHWdVq+eJx4uhL+xv5dnS6D/aunVrarPPaPr06Vm/l156KbV5VhbI/Wfsq2PfXDwmR13Mnz8/6xdnnKvw7C2Q+4N55jj6tGL0g2hP6umInyv2eXIUBDB0HUU/J+uI52IGqyP280YdsU+V52mi35j3q6ejV155JbX5nnF0A5DriKNHxo/PF/SIY1YtlF4shBAloMFXCCFKoKVuhyNHjqTwqBhexSEyHBwdYxrfeuut1L7mmmtSO5ocbO6wecPhMkDuJuAkBg6DAfKQFjZ7oonBAdw9PT3ZNjZPOLwnZvdwKM3VV1+d2hwGE69jzpw5qR0D79lE4qyd6LaI1yHak0Z1xM9ETEDgZ4l1FPXGx2dN1dMRnzfqiEPe2HXBugZyLXJoJ1BbRxwKBuQ6YjdL1BG7A2fNmlWzHx+vXkJWozqS2oQQogQ0+AohRAm01O3Q29ubzJr4as6mytln99Wh4KwwIDctOMsmZtJcemnfWpTLly9P7SuvvDLrx6bU5s2b+90fAFauXJnabPZMnpyv2cfuiWiOsNnCs7Qxd52PzzPMMWOOC4SwuRmzlHimm+/7tGnTsn4x6kK0J/V0xC471hFHLQCN6+iyyy5L7X//939P7agjdu2xCyLqaNWqVanNz3m8Po7EiRmbtXQU66ywy4R1FDPm+DuzO6Wejvj+xWiMRnWkN18hhCgBDb5CCFECGnyFEKIEWurzNbPkw+VqXUDun2EfSr3sLw4ziZWEOIxqwYIFqV2tBlWFfVVLlixJ7RdffDHrt3jx4tTmWqPRz8ShOjEMiEPAOMwmZguxT4v9unHVEc7AiZlJDPvPNm3alNrRX6hShScGzdAR1/Dl33vUET/r9XTE52UdxQy8RYsWpTZnlsV6wxwaF6uQ8TbWTsxeZR2xX7cZOuL5oXqF6uuhN18hhCgBDb5CCFECLXU7jB49GpdffjmAY0O02PTh4iAxDItDqt7//venNpvT8RichRZDX9iE4Sy5mC3D4TgXX3xxaj/44INZPy4CHTNkOLuMi9/EkDQ2x9gkqle0me9TPB67Rtjc5GJGwLH3ULQno0ePTuZ7DNFik7eejjikinX0wgsvZP3Y5OfCMgsXLsz6sX65HZcB4wUAWEcPPPBA1o91FLPf+Lnn57ne0kaso+haaVRHvI3DNDncDWhcR3rzFUKIEtDgK4QQJdBSt0NXV1cyhaLJyzOGPHMa16hiatXhBHLzi038mN3CZhCb9XFNOM6E27atb6HZWIeU3RWxlimbcDxbGuuB8swsz+DG6An+/mzexWufNGlSavOsMmftAcfWLxXtSVdXV9JP1EctHUW9MRzREDNK2RXHJj7X5QVytxy71+KzyNfEx4g6Yj1HfbCu2MSP9ak5UoijPeLx2D3BOuIMQSB3ldbTEd+neujNVwghSkCDrxBClIAGXyGEKIGW+nzHjBmTioPHsBCuIMR+rOjTYn9SrUwwIPdVcchXDM2pFRYTs2DYv8ohN4cOHcr6sV83Zu3wudg/FTNzODSOw8TiNXGISzWEDzg2xI3XZuPQuuibimFGoj1hHcVwKPaxsp+3UR3Fqma1dBQrfvE2Pl7M/mL/Mj/nUUfsG45hcnwurngWdcQ65fEhXhPriEPo4qIEPD/EWo7VARvVkd58hRCiBDT4CiFECbTU7XD48OFkdvCaSkBuSnBoVDQROMONTalofrH5z+3Vq1dn/Tikhc2buEZVrbCdGN7C2Tgxu6dWAeu4ZDuHwvC2GE7H52ZTh+8fkN9DNs1i8aDokhHtyeHDh5MbLOqITW1+DuKzU0tHsbDMYHTEJn48Xq0w0ligir9HDH/jvvw92C0A5C4JdnHE47HeuBBQLFrE35HdJFFHMXu3FnrzFUKIEhhw8DWz75nZbjNbS5+dZWYPm9nG4v/x9Y4hhJCWRE4jboc7AfwNgO/TZ7cB+Lm732FmtxU/3zrQgbq7u7OCGQyv+8SzjLzUNJCbLexqiGYLm+tsasciGHwMntmNpvuTTz7Z7zGiW4RNmhh1wGYW94trVLF5w+ZSvbWs2NSJM8d8HWxKxdncmLUkms6daIKWuru7k4soFonhDE6ObGlURzGygHXEz1U9HXE2WdTRU0891e8xoluEn+3olmO3H7vy4ndkjbGOYoYb9+PrjYWsWC/cj+8z0LiOBnzzdfdfANgTPl4K4K6ifReAjzd0NiE6GGlJMIP1+U5092qg7i4AE2t1NLNbzGyFma3gvz5CCAANakk6GnkMecLNK5H/Xmf7Mndf7O6LY2EYIUQf9bQkHY08Bhtq9qqZTXL3nWY2CcDuAfdAxT9a9dHEDDcurMw+o2eeeSbrx9kk7AuaM2dO1o9DubZv357a9Sp3sd+YM9oA4Lrrrkttzm554oknsn7s045+Ma5kxv6pZ599tua59uzps1Kjr4qvkTOb4nnZL8j+rZgVqDXcSuG4tWRmyScaQ7mGqqPZs2dn/TiUizXFlQKr11SFMzujjrhwO1cefPzxx7N+rKOYnceVzPi5j+FvfC7+jjE8lK+R50TiedkHXE9H0Qdci8G++d4P4KaifROAnwzyOEJ0OtJSh9JIqNkPATwOYLaZbTezzwG4A8BHzGwjgA8XPwsh6iAtCWZAt4O7f6bGpg8d78mOHj2aXv9jiBYXLubiHtGdwCEpV1xxRWpv2LAh68dmAZsVU6ZMyfpxYWYOYYnZaWx+8TXMnTs368cFS2KREi6MwyZSDJFh85/D3+Iy3DfccENq8/2MBXg4HIdNpBjeUysMUDSHZmmJdRR/hxyOyL/rqCPWx+LFi1M76oh1wK7CmMXFrq56OmLXBV97vD428aNZz240dtnF4ue1dBTXWPvYxz6W2vV0xNfLLsq43uPUqVPRCMpwE0KIEtDgK4QQJdDSwjpA36t7nElct25das+bNy+148wkF7FYvnx5akcziOuNLl26NLXjTCS7BjiLbcmSJVm/WbNmpfZ3vvOd1OZiI0BucsVMMzbbZs6cmdpxJrpWKBHPXgO5O4X3iXWE2XxiN0vsx1Ehor2pmsfRtbV+/frUZpdYjJRhHfFzGd1yrKPf/M3fTO16OuIstqgjjqZgHcUIHR4foo44m66ejqI2q7ALAqito5jtxzqqpzeuWVwPvfkKIUQJaPAVQogS0OArhBAl0FKf78knn5zCQWKIDIducMgIVzsD8lAQztKJ/kr293CRZQ4FA/KMFs5+Y78VkPt1+NgcOgPk4S0xBIX9WPw9om/queeeS232kUXfEofjcDteU62i87GodAz/E+1JPR3xnEM9HfF+06dPT+2oI/bF1tMRP0usI55HAXI/Kj/3HMoJ5DqKz2n0D/d3PCAPQ+PMv0Z1FIuz871lP/lgdaQ3XyGEKAENvkIIUQItdTv09vamEJW49DSvfcamTzQlOIOHzeuYacZmCxfwiCFufC5eBy0WQmcThIsqx2Wi2X3CZgqQm0tsfsUwIL4XvE80l7hYCIe+xCW02ZTicoTRPRHNJ9Ge9Pb2puebC8sA+bPJpnHUEbsk2OSPmWaN6ojDtVgT/CwDtXUUszdZRzGcjs/NOoohmqxh1mK9gvF8jBjayfvx94ruiUZ1pDdfIYQoAQ2+QghRAi21M7u7u1MmWjR5+dX9kksuSe1YtZ/NIJ5x5QgBIJ9x5X6cAQTk6y1xhkxcv4mPH5epZ7j+7uWXX55t4wIhHAkxf/78rB+bd2vWrEntOMvLWXecfVNvXTk22WI0RqyxLNoTXsMtmrz8/PEMf9QRP2PspmpURz09PVm/ZuuIXQFRR+yS4Gebxw0gdxvU0xFnyXHRnhhJwnphHcXiQY3qSG++QghRAhp8hRCiBDT4CiFECbTU53vgwIGU8RLXgGJ/KPuC2L8DAG+++Wa/+8TKRw8++GBqc5Wh6PtiXxCvsXbZZZdl/bjINB8jFiBnP9Ojjz6abWP/Ge/39NNPZ/04nI5DZNgfBeR+3lipiWGfFB8vVoxTVbMTg2briLfFMMWHHnootVlHvD+Q+3JZRwsXLsz6cRga6yhWU+PnOepoxowZqV31fQP1dcThalFHDOs3zp1wqCfrKPqGG9WR3nyFEKIENPgKIUQJtNTtcNJJJ6XXf85uAfLMEi6IwYXVAWDlypWpzQVBYjYZZ9w89thjqR3Xb2JTgsNHFixYkPVbsWIF+iOGzMXwLYaX+WYzKGa4cT++jueffz7rx+YOh7dEE5OPz6F20VyKWX2iPWEdxaLmtXTEYWfA4HTEy7vHjLRaJnl0O6xatQr9UU9H0RVSy50SM9xYRxzOGbNS+Vx87JgJx8fnQkVR8zGrrxZ68xVCiBLQ4CuEECWgwVcIIUqg5WWsqumG0S/CPhROm+W0RSD3S7LfiRcEBHLfDR8j+oU4HZPDZ+69996a/TjEi9OdgTzUJ8LXzj7vmGb5yU9+MrXZn7Ro0aKax+PwmRhOx/44vvaY+hl/Fu1L9fcYQ74GoyP2gcai6/xsbtmyJbWjjjgdmJ+/e+65J+vHOuJn9nh0xGMH64h9vADwiU98IrU5DTmmK/O9iP5lJqYRVxmsjgZ88zWz883sETNbb2brzOyLxednmdnDZrax+H/8QMcSopORlgTTiNvhCICvuPs8AFcD+O9mNg/AbQB+7u4zAfy8+FkIURtpSSQGdDu4+04AO4v222bWA2AygKUAPlB0uwvAcgC31juWmaXwDTY/AGDs2LGp/ctf/jK1OYMFONbMqvLyyy9nP3OBaM5Wi1ldbFZxmzPfgNz8r5chw5k5MUOGw2K2bduW2pdeemnW7x//8R9T+/3vf3/N47EZxBlCsXA2hwtxEe0Y3lNrbSzRHJqlJTNLZnR0MQ1GR7zPYHXEJj+HPUYdcXgjt9kdBuQ6iiGRHKbJ2WQxrO3uu+9O7Xo6Ym1z5mksGM/fi3UUK8s1qqPjmnAzs+kALgPwJICJxcMEALsATKyxzy1mtsLMVtQaOIXoNI5XS9LRyKPhwdfMTgfwIwBfcvdstswrf7a8v/3cfZm7L3b3xfwXVohOZTBako5GHg1FO5hZNyoPy93u/uPi41fNbJK77zSzSQB2D3Scd955B6tXrwZwrBnE2TjMunXrsp+58AUX8IhrT7GJzw9rzODhpeM5KiDOtrJ5w28ece24GHXBsLkTCwExPBvL5l3MCuRrZ7MvFinh87I5FzProhtCNJ9maOmdd95JhWyqixNUYR3x7z3qiJ8/fmZjRilv4wiHaJLzudgdVk9HHLUQ9cvnjW6CWjqKUQbsJuFnvVEdxXvL7g8eh2LkR6M6aiTawQB8F0CPu3+bNt0P4KaifROAnzR0RiE6FGlJMI28+f4agN8DsMbMVhef3Q7gDgD3mdnnAGwB8OnhuUQhRgzSkkg0Eu3wKwBWY/OHmns5QoxcpCXBtDTDrbe3N2WTxGwUzkDhLBuuuATkC/9xRadYWYiLTHNoWCw6Hv0/VaIvl4/PPq2YqceVkKJPlb8j+56jX4wzbrgdfV+7d/e5Bjm8JX4n/i58/2JWEYfwiPaFdRSzI2vp6IILLsj6sV+yno6i/qrwcwQ0riP2m7JWoo7qVSvj78jPbNQRfy++vhjWxjriMM2oD/ZL87Z4LxrVkWo7CCFECWjwFUKIEmip22HUqFHJ/IkFPNhNwCZCDGnhDBTOkotFmtnkZzdBDPFic53NlBguwiYSrw0Vi22wOyEWY+bwFA5riyEybPrwvZg5c2bWj7dxeFk0lzjDjc3KeH31wt9E+zBq1KjkDogZaexeYJdVDLGspaO4aACHafKzE913rFN2j0UdsTuBdcR6AHLTvVEdRXcCXztrhdeAA/L71KiO2H0SFy+oV5yH0ZuvEEKUgAZfIYQogZa7HaqZbdFc5wIhU6dOTe04w8+FPjgz5frrr8/6cREMzhKrV0yGzYojR45k/XgmleufxmwynrWNx+DvXK9QD7tMeFvsN2HChNTmrDueDQbyGWue2eX9gWOzoER7MmrUqOQ2qKejadOmpXY9HU2c2FdKIuqIoyka1RHvE01wNtG5HnfMeK2nI36++fsPVkdcJIfrEkcd8f1kHfH+ALB27Vo0gt58hRCiBDT4CiFECWjwFUKIEmj5Gm5Voq+K/TPsj5o0aVLWj/017BeK/plNmzal9tKlS1M7hrTw8TkcJxZI5tAX9tfGQs/sN44hMhxex9cRw4A4bIe/Vz3fF/vtoi+XQ9l4n1jQfv78+RAnBlUdxDCnWjqKPlXWEc8XxAy3RnXE8y+slagjnjth7cTzso7id+SKZ3wdMbOM/dA83kQ/NJ97MDqK/u9LLrkEjaA3XyGEKAENvkIIUQItdTt0dXWlIhmcVQLk5j+bMBE2GeoV1WCTv1rAHcizY4C8aAcXyIjXwKYJH+OZZ57J+nEhdC72Ho/J1x7XfGJTjV0rs2fPzvpxuAubZnGZcA4Ruvbaa1N75cqVWb9YIES0J6yjWJCGM9eiy47hbEZ2c0UTn3XFOooZbuzu4G3xGtjVwNcQF1NgHbHrIx6Try9mw7JbjbNXZ82alfVjHfG4EXXEGXnXXHNNakcdxXtTC735CiFECWjwFUKIEmip2+HUU09N9T15VhEAHn300dRmkyNGMbB5wxkycbaUM3ouuuii1N6yZUvWj7PV6tUX5Z+5SEesV8oRDTHzhbOP2H0SXTBsLtWrDcruD57Nju4DNsd4Ke8Y7RDvtWhP6ulo+fLlqb1o0aLUbraOokm+YcOG1GYdxWebIyvYFRDXcGOX3XDriN0frKPoomQdcRYbZ8UBjetIb75CCFECGnyFEKIENPgKIUQJtHwNt6q/NBYqnjx5cmqznymu38Q+Iw5biT5aDq9i30/0H3F2Cme0xDXm2K/DfrYYJsb7xe/IISi1qrMBwLx581I7hv4wfL1cSLpecWfeJ4bmxGpPoj2pp6NYZa9K1BH7TZmoI/YNswaijvh55m1RR3zec845J7Xjs8iV0eIcBuuIw8SijjjTLGbkMRxCxkQdsW+4VmYscGxR91rozVcIIUpAg68QQpRAS90Ohw4dwrZt2wDka7YB+as7myAcjgLkBY05TIzDYIB8TTcuJs5FOYA8LIRdGjEzh00pNrHi0trs4ogmF68pxZlIMaSFTT8O/YnLf3PxEXafsMsFyN0ztdasAxpfe0qUS6M64nY9HXGoWdQRZ3Dysx6zN7lwDbsWYigcu71YR/HZZhfHYHXE18Huk3guXniBdcT7AI3rqNG1EPXmK4QQJTDg4Gtmp5rZU2b2rJmtM7NvFp9fYGZPmtkmM7vXzGp7tIUQ0pLIaMTtcBDAB919v5l1A/iVmf0UwJcB/KW732Nmfw/gcwD+rt6BxowZg8WLFwM4dr0wNoPY/OfZTCAvisHFLWKWCZvePCPM5wHymcmqKQccu+YVL+e+Y8eO1I6zvmxWRbOFC5PwzGys08tmEZtmPT09WT82ueIsNcOZPzxTXG8tKzEsNEVLo0ePTtlr9Z6JejriIk2so1h/l59hNq95ncVIzH5j2FyvpyP+uZ6O2D1YT0f8/devX5/14+/COopjAG/jCIwY3dCojgZ88/UK1Xza7uKfA/gggH8pPr8LwMcbOqMQHYq0JJiGfL5m1mVmqwHsBvAwgM0A9rl79U/NdgCTa+x7i5mtMLMV/BYnRCcyWC2xjuLKCeLEpKHB192PuvtCAFMAXAlgzgC78L7L3H2xuy+WWSs6ncFqiXUUl7cRJybHFWrm7vvM7BEASwCMM7OTi7/YUwDsqL93xTdS9ctwxSUgrxTGPsqYfcL+nhkzZqR29FVxOAr7OTmsBMh9w1zRKBZn5zAsXussvs1zlTP2aQG5f4p9yDFDho+5cOHC1N6+fXvWj316nC0UfWSc3cOFqaPfLobMiOFjqFqqrifGFQCBXEfcjgN2LR3Ft2p+TuvpiHXK2aqN6ij6pC+++OLU5rkYINcR+5Bj5TLWEd+neLxaoXExK5B1xCGrcR4pVlerRSPRDmeb2biifRqAjwDoAfAIgBuLbjcB+ElDZxSiQ5GWBNPIm+8kAHeZWRcqg/V97v6Ama0HcI+Z/TmAZwB8dxivU4iRgLQkEtZoEYimnMzsNQAHAGjGoMIEtO+9mObuctK3IYWOtqC9n59W0673oqaOWjr4AoCZrXD3xS09aZuieyGGgp6fPk7Ee6H0YiGEKAENvkIIUQJlDL7LSjhnu6J7IYaCnp8+Trh70XKfrxBCCLkdhBCiFDT4CiFECbR08DWzj5rZhqJu6W2tPHfZmNn5ZvaIma0varl+sfj8LDN72Mw2Fv+PH+hYQnSqlkaSjlrm8y2yel5AJaVyO4CnAXzG3dfX3XGEYGaTAExy91VmdgaAlaiUDrwZwB53v6MQ0Xh3v7XESxVtTidraSTpqJVvvlcC2OTuL7r7IQD3AFjawvOXirvvdPdVRfttVHL6J6NyD+4quqmWq2iEjtXSSNJRKwffyQC4nFDNGsAjHTObDuAyAE8CmOju1RJRuwBMrLGbEFWkJZz4OtKEW4sxs9MB/AjAl9w9W/vHKz4gxf4JMQAjQUetHHx3ADiffm6obulIoli360cA7nb3Hxcfv1r4sar+rN219heioKO1NFJ01MrB92kAM4uVWkcB+G0A97fw/KVildX4vgugx92/TZvuR6WGK6BarqIxOlZLI0lHrS4p+TEAfwWgC8D33P1/tuzkJWNm1wL4JYA1AKrLBt+Oir/qPgBTUSkT+Gl331PKRYoThk7V0kjSkdKLhRCiBDThJoQQJaDBVwghSkCDrxBClIAGXyGEKAENvkIIUQIafIUQogQ0+AohRAn8fxEVF58NiAvnAAAAAElFTkSuQmCC\n",
+            "text/plain": [
+              "<Figure size 432x288 with 4 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    }
+  ]
+}

visualization/Learning_Curves.py

@@ -0,0 +1,115 @@
+from sklearn.metrics import roc_curve
+from sklearn.metrics import auc
+from matplotlib import pyplot as plt
+from scipy import interp
+
+# import cleverhans
+import sys
+import pickle
+import numpy as np
+import warnings
+
+warnings.filterwarnings("ignore")
+
+import os
+
+plt.rcParams.update({"font.size": 14})
+
+## add your path
+prefix = +"logs/"
+
+
+def learning_curves(percent, epsilon, exp, curve_type):
+    acc_list = []
+    "Ten fold CVs of ResNet"
+    BS = 64
+    init = (32, 32, 1)
+    sgd = SGD(lr=0.1, momentum=0.9)
+    model_name = prefix + exp + "/ResNet_" + str(epsilon) + "_" + str(percent)
+    for j in range(10):
+        hist_name = model_name + "_" + curve_type + "" + "_" + str(j) + ".pickle"
+        with open(hist_name, "rb") as f:
+            acc = pickle.load(f)
+        acc_list.append(acc)
+    return acc_list
+
+
+def learning_curves_plot(train_sizes, mean_acc, std_acc, exp, curve_type):
+
+    plt.figure(dpi=80)
+    # Draw lines
+    plt.fill_between(
+        train_sizes, mean_acc - std_acc, mean_acc + std_acc, alpha=0.1, color="r"
+    )
+    plt.plot(mean_acc, "-", color="r", label="ResNet")
+
+    plt.fill_between(
+        train_sizes,
+        mean_list[0] - std_list[0],
+        mean_list[0] + std_list[0],
+        alpha=0.1,
+        color="darkgreen",
+    )
+    plt.plot(mean_list[0], "-", color="darkgreen", label="ResNet-0.25 AEs")
+
+    plt.fill_between(
+        train_sizes,
+        mean_list[1] - std_list[1],
+        mean_list[1] + std_list[1],
+        alpha=0.1,
+        color="darkblue",
+    )
+    plt.plot(mean_list[1], "-", color="darkblue", label="ResNet-0.5 AEs")
+
+    plt.fill_between(
+        train_sizes,
+        mean_list[2] - std_list[2],
+        mean_list[2] + std_list[2],
+        alpha=0.1,
+        color="darkorange",
+    )
+    plt.plot(mean_list[2], "-", color="darkorange", label="ResNet-0.75 AEs")
+
+    plt.fill_between(
+        train_sizes,
+        mean_list[3] - std_list[3],
+        mean_list[3] + std_list[3],
+        alpha=0.1,
+        color="magenta",
+    )
+    plt.plot(mean_list[3], "-", color="magenta", label="ResNet-1.0 AEs")
+
+    # # Create plot
+    plt.title("Learning Curves of Models (epsilon={})".format(epsilon))
+    plt.xlabel("Epoch"), plt.ylabel(curve_type), plt.legend(loc="best")
+    plt.tight_layout()
+
+    plt.savefig(prefix + exp + curve_type + "/" + str(epsilon) + ".png")
+
+
+train_sizes = [i for i in range(50)]
+
+epsilons = [0.001, 0.003, 0.005, 0.01, 0.03]
+
+percents = [0.25, 0.5, 0.75, 1.0]
+
+Curve_Types = ["loss", "acc"]
+
+Experiment = ["AEModels", "RandomNoisemodels"]
+
+
+for exp in Experiment:
+    for curve_type in Curve_Types:
+
+        for epsilon in epsilons:
+
+            mean_list, std_list = [], []
+            train_mean_list, train_std_list = [], []
+
+            for percent in percents:
+
+                acc_list = learning_curves(percent, epsilon, exp, curve_type)
+                mean_list.append(np.mean(acc_list, axis=0))
+                std_list.append(np.std(acc_list, axis=0))
+
+            learning_curves_plot(train_sizes, mean_acc, std_list, exp, curve_type)

visualization/ROC_curves.py

@@ -0,0 +1,254 @@
+from sklearn.metrics import roc_curve
+from sklearn.metrics import auc
+from matplotlib import pyplot as plt
+from scipy import interp
+
+# import cleverhans
+import sys
+import tensorflow as tf
+
+# from cleverhans.tf2.attacks.fast_gradient_method import fast_gradient_method
+from tensorflow.keras.optimizers import SGD
+from tensorflow.keras.callbacks import Callback, LearningRateScheduler
+from sklearn.model_selection import train_test_split
+import pandas as pd
+from sklearn.model_selection import KFold
+import gzip
+import pickle
+import numpy as np
+import warnings
+
+warnings.filterwarnings("ignore")
+import tensorflow
+
+print("\nTensorflow Version: " + tf.__version__)
+from wresnet import WideResidualNetwork
+from parsevalnet import ParsevalNetwork
+import hickle as hkl
+import os
+
+plt.rcParams.update({"font.size": 14})
+## add your path
+prefix = ""
+
+
+def ROC_result(model):
+
+    fpr = dict()
+    tpr = dict()
+    roc_auc = dict()
+    y_score = model.predict(X_test)
+    # # Compute micro-average ROC curve and ROC area
+    fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel())
+    return fpr, tpr
+
+
+def plot_roc(
+    fpr_l, tpr_l, roc_auc_l, std_tpr_list, std_roc_auc_list, epsilon, fig_name
+):
+
+    plt.figure(figsize=(10, 8))
+    lw = 2
+
+    plt.fill_between(
+        fpr_l,
+        tpr_l[0] - std_tpr_list[0],
+        tpr_l[0] + std_tpr_list[0],
+        alpha=0.1,
+        color="purple",
+    )
+    plt.plot(
+        fpr_l,
+        tpr_l[0],
+        color="purple",
+        lw=lw,
+        label="ResNet (area = %0.4f)" % roc_auc_l[0],
+    )
+
+    plt.fill_between(
+        fpr_l,
+        tpr_l[1] - std_tpr_list[1],
+        tpr_l[1] + std_tpr_list[1],
+        alpha=0.1,
+        color="darkgreen",
+    )
+    plt.plot(
+        fpr_l,
+        tpr_l[1],
+        color="darkgreen",
+        lw=lw,
+        label="ResNet-0.25 AEs(area = %0.4f)" % roc_auc_l[1],
+    )
+
+    plt.fill_between(
+        fpr_l,
+        tpr_l[2] - std_tpr_list[2],
+        tpr_l[2] + std_tpr_list[2],
+        alpha=0.1,
+        color="darkblue",
+    )
+    plt.plot(
+        fpr_l,
+        tpr_l[2],
+        color="darkblue",
+        lw=lw,
+        label="ResNet-0.50 AEs(area = %0.4f)" % roc_auc_l[2],
+    )
+
+    plt.fill_between(
+        fpr_l,
+        tpr_l[3] - std_tpr_list[3],
+        tpr_l[3] + std_tpr_list[3],
+        alpha=0.1,
+        color="pink",
+    )
+    plt.plot(
+        fpr_l,
+        tpr_l[3],
+        color="pink",
+        lw=lw,
+        label="ResNet-0.75 AEs(area = %0.4f)" % roc_auc_l[3],
+    )
+
+    plt.fill_between(
+        fpr_l,
+        tpr_l[4] - std_tpr_list[4],
+        tpr_l[4] + std_tpr_list[4],
+        alpha=0.1,
+        color="darkorange",
+    )
+    plt.plot(
+        fpr_l,
+        tpr_l[4],
+        color="darkorange",
+        lw=lw,
+        label="ResNet-1.0 AEs (area = %0.4f)" % roc_auc_l[4],
+    )
+
+    plt.fill_between(
+        fpr_l,
+        tpr_l[5] - std_tpr_list[5],
+        tpr_l[5] + std_tpr_list[5],
+        alpha=0.1,
+        color="darkmagenta",
+    )
+    plt.plot(
+        fpr_l,
+        tpr_l[5],
+        color="darkmagenta",
+        lw=lw,
+        label="Parseval (area = %0.4f)" % roc_auc_l[5],
+    )
+
+    plt.plot(np.arange(0, 1, 0.001), np.arange(0, 1, 0.001), linestyle="--")
+
+    plt.xlabel("False Positive Rate")
+    plt.ylabel("True Positive Rate")
+    plt.title("ROC For Epsilon = {}".format(epsilon))
+    plt.legend(loc="lower right")
+
+    plt.xscale("log")
+
+    plt.savefig(fig_name)
+
+
+BS = 64
+init = (32, 32, 1)
+sgd = SGD(lr=0.1, momentum=0.9)
+
+data = hkl.load("data.hkl")
+X_train, X_test, Y_train, y_test = (
+    data["xtrain"],
+    data["xtest"],
+    data["ytrain"],
+    data["ytest"],
+)
+
+Experiment = ["AEModels", "RandomNoisemodels"]
+epsilons_list = [0.03, 0.01, 0.005, 0.003, 0.001]
+percent_list = [0, 0.25, 0.5, 0.75, 1.0]
+
+for exp in Experiment:
+
+    for epsilon in epsilons_list:
+        for percent in percent_list:
+            tprs = []
+            aucs = []
+            mean_fpr = np.arange(0, 1, 0.001)
+            mean_fpr_list = []
+            mean_tpr_list = []
+            mean_roc_auc_list = []
+            std_fpr_list = []
+            std_tpr_list = []
+            std_roc_auc_list = []
+            micro_roc_auc = []
+            fpr_list, tpr_list, roc_auc_list = [], [], []
+            for i in range(10):
+                resnet = WideResidualNetwork(
+                    init, 0.0001, 0.9, nb_classes=4, N=2, k=1, dropout=0.0
+                )
+                model = resnet.create_wide_residual_network()
+                model.compile(
+                    loss="categorical_crossentropy", optimizer=sgd, metrics=["acc"]
+                )
+                if percent != 0:
+                    model_path = (
+                        prefix
+                        + ex
+                        + "/ResNet_"
+                        + str(epsilon)
+                        + "_"
+                        + str(percent)
+                        + "_"
+                        + str(i)
+                        + ".h5"
+                    )
+                    print(model_path)
+                    model.load_weights(model_path)
+                else:
+                    model_path = prefix + "ResNet/ResNet_" + str(i) + ".h5"
+                    print(model_path)
+                    model.load_weights(model_path)
+                    fpr, tpr = ROC_result(model)
+                    tprs.append(interp(mean_fpr, fpr["micro"], tpr["micro"]))
+                    roc_auc = auc(fpr["micro"], tpr["micro"])
+                    aucs.append(roc_auc)
+                    tpr_list.append(tprs)
+                    roc_auc_list.append(aucs)
+                    init = (32, 32, 1)
+                    parseval_micro_fpr, parseval_micro_tpr, parseval_micro_roc_auc = (
+                        [],
+                        [],
+                        [],
+                    )
+for i in range(10):
+    parseval = ParsevalNetwork(init, 0.0001, 0.9, nb_classes=4, N=2, k=1, dropout=0.0)
+
+    model = parseval.create_wide_residual_network()
+    model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["acc"])
+    model_name = prefix + "ResNet/Parseval_" + str(i) + ".h5"
+    model.load_weights(model_name)
+    fpr, tpr = ROC_result(model)
+    parseval_micro_tpr.append(interp(mean_fpr, fpr["micro"], tpr["micro"]))
+    roc_auc = auc(fpr["micro"], tpr["micro"])
+    parseval_micro_roc_auc.append(roc_auc)
+    parseval_micro_roc_auc.append(roc_auc)
+    tpr_list.append(parseval_micro_tpr)
+    roc_auc_list.append(parseval_micro_roc_auc)
+
+    for i in range(6):
+        mean_tpr_list.append(np.mean(tpr_list[i], axis=0))
+        mean_roc_auc_list.append(auc(mean_fpr, mean_tpr_list[i]))
+        std_tpr_list.append(np.std(tpr_list[i], axis=0))
+        std_roc_auc_list.append(auc(mean_fpr, std_tpr_list[i]))
+
+    fig_name = prefix + exp + "/ROC/Model_Epsilon" + str(epsilon) + ".png"
+    plot_roc(
+        mean_fpr,
+        mean_tpr_list,
+        mean_roc_auc_list,
+        std_tpr_list,
+        std_roc_auc_list,
+        epsilon,
+        fig_name,
+    )

visualization/performance_plot.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+plt.rcParams.update({"font.size": 14})
+## add your path
+prefix = +"logs/"
+
+
+def plot_figure(x_acc, x_size, y_err, title, epsilon, exp):
+    plt.figure(figsize=(10, 8))
+    plt.errorbar(x_001, y_001_acc, yerr=yerr, fmt="o", label="ACC")
+    plt.title("{0} = {0}".format(title, epsilon))
+    plt.xlabel("Percent of Adversarial Examples")
+    plt.ylabel("Accuracy")
+
+    plt.savefig(prefix + exp + "/performance/" + str(epsilon) + ".png")
+
+
+Experiment = ["AEModels", "RandomNoisemodels"]
+
+
+for exp in Experiment:
+    columns = ["Model_ID", "percent", "epsilon", "accuracy", "attack"]
+
+    table = pd.DataFrame(columns=columns)
+    table
+    for file in os.listdir(prefix + exp):
+        format = file.split("_")[3].split(".")[-1]
+        if format == "h5":
+            epsilon = file.split("_")[1]
+            percent = file.split("_")[2]
+            ModelID = file.split("_")[3].split(".")[0]
+            resnet = WideResidualNetwork(
+                init, 0.0001, 0.9, nb_classes=4, N=2, k=1, dropout=0.0
+            )
+            resnet_model = resnet.create_wide_residual_network()
+            resnet_model.compile(
+                loss="categorical_crossentropy", optimizer=sgd, metrics=["acc"]
+            )
+            resnet_model.load_weights(prefix + exp + "/" + file)
+            acc = resnet_model.evaluate(X_test, y_test)
+
+            row = {
+                "Model_ID": ModelID,
+                "percent": percent,
+                "epsilon": epsilon,
+                "accuracy": acc[1],
+                "attack": 0,
+            }
+            table = table.append(row, ignore_index=True)
+    tab_25 = table[table["percent"] == "0.25"]
+    tab_5 = table[table["percent"] == "0.5"]
+    tab_75 = table[table["percent"] == "0.75"]
+    tab_1 = table[table["percent"] == "1.0"]
+
+    tab_25_001 = tab_25[tab_25["epsilon"] == "0.001"]
+    tab_25_001["mean_acc"], tab_25_001["mean_att"] = (
+        sum(tab_25_001["accuracy"]) / 10,
+        sum(tab_25_001["attack"]) / 10,
+    )
+    tab_25_01 = tab_25[tab_25["epsilon"] == "0.01"]
+    tab_25_01["mean_acc"], tab_25_01["mean_att"] = (
+        sum(tab_25_01["accuracy"]) / 10,
+        sum(tab_25_01["attack"]) / 10,
+    )
+    tab_25_03 = tab_25[tab_25["epsilon"] == "0.03"]
+    tab_25_03["mean_acc"], tab_25_03["mean_att"] = (
+        sum(tab_25_03["accuracy"]) / 10,
+        sum(tab_25_03["attack"]) / 10,
+    )
+    tab_25_005 = tab_25[tab_25["epsilon"] == "0.005"]
+    tab_25_005["mean_acc"], tab_25_005["mean_att"] = (
+        sum(tab_25_005["accuracy"]) / 10,
+        sum(tab_25_005["attack"]) / 10,
+    )
+    tab_25_003 = tab_25[tab_25["epsilon"] == "0.003"]
+    tab_25_003["mean_acc"], tab_25_003["mean_att"] = (
+        sum(tab_25_003["accuracy"]) / 10,
+        sum(tab_25_003["attack"]) / 10,
+    )
+
+    tab_5_001 = tab_5[tab_5["epsilon"] == "0.001"]
+    tab_5_001["mean_acc"], tab_5_001["mean_att"] = (
+        sum(tab_5_001["accuracy"]) / 10,
+        sum(tab_5_001["attack"]) / 10,
+    )
+    tab_5_01 = tab_5[tab_5["epsilon"] == "0.01"]
+    tab_5_01["mean_acc"], tab_5_01["mean_att"] = (
+        sum(tab_5_01["accuracy"]) / 10,
+        sum(tab_5_01["attack"]) / 10,
+    )
+
+    tab_5_03 = tab_5[tab_5["epsilon"] == "0.03"]
+    tab_5_03["mean_acc"], tab_5_03["mean_att"] = (
+        sum(tab_5_03["accuracy"]) / 10,
+        sum(tab_5_03["attack"]) / 10,
+    )
+    tab_5_005 = tab_5[tab_5["epsilon"] == "0.005"]
+    tab_5_005["mean_acc"], tab_5_005["mean_att"] = (
+        sum(tab_5_005["accuracy"]) / 10,
+        sum(tab_5_005["attack"]) / 10,
+    )
+    tab_5_003 = tab_5[tab_5["epsilon"] == "0.003"]
+    tab_5_003["mean_acc"], tab_5_003["mean_att"] = (
+        sum(tab_5_003["accuracy"]) / 10,
+        sum(tab_5_003["attack"]) / 10,
+    )
+    tab_1_001 = tab_1[tab_1["epsilon"] == "0.001"]
+    tab_1_001["mean_acc"], tab_1_001["mean_att"] = (
+        sum(tab_1_001["accuracy"]) / 10,
+        sum(tab_1_001["attack"]) / 10,
+    )
+    tab_1_01 = tab_1[tab_1["epsilon"] == "0.01"]
+    tab_1_01["mean_acc"], tab_1_01["mean_att"] = (
+        sum(tab_1_01["accuracy"]) / 10,
+        sum(tab_1_01["attack"]) / 10,
+    )
+    tab_1_03 = tab_1[tab_1["epsilon"] == "0.03"]
+    tab_1_03["mean_acc"], tab_1_03["mean_att"] = (
+        sum(tab_1_03["accuracy"]) / 10,
+        sum(tab_1_03["attack"]) / 10,
+    )
+    tab_1_005 = tab_1[tab_1["epsilon"] == "0.005"]
+    tab_1_005["mean_acc"], tab_1_005["mean_att"] = (
+        sum(tab_1_005["accuracy"]) / 10,
+        sum(tab_1_005["attack"]) / 10,
+    )
+    tab_1_003 = tab_1[tab_1["epsilon"] == "0.003"]
+    tab_1_003["mean_acc"], tab_1_003["mean_att"] = (
+        sum(tab_1_003["accuracy"]) / 10,
+        sum(tab_1_003["attack"]) / 10,
+    )
+
+    tab_75_001 = tab_75[tab_75["epsilon"] == "0.001"]
+    tab_75_001["mean_acc"], tab_75_001["mean_att"] = (
+        sum(tab_75_001["accuracy"]) / 10,
+        sum(tab_75_001["attack"]) / 10,
+    )
+    tab_75_01 = tab_75[tab_75["epsilon"] == "0.01"]
+    tab_75_01["mean_acc"], tab_75_01["mean_att"] = (
+        sum(tab_75_01["accuracy"]) / 10,
+        sum(tab_75_01["attack"]) / 10,
+    )
+    tab_75_03 = tab_75[tab_75["epsilon"] == "0.03"]
+    tab_75_03["mean_acc"], tab_75_03["mean_att"] = (
+        sum(tab_75_03["accuracy"]) / 10,
+        sum(tab_75_03["attack"]) / 10,
+    )
+    tab_75_005 = tab_75[tab_75["epsilon"] == "0.005"]
+    tab_75_005["mean_acc"], tab_75_005["mean_att"] = (
+        sum(tab_75_005["accuracy"]) / 10,
+        sum(tab_75_005["attack"]) / 10,
+    )
+    tab_75_003 = tab_75[tab_75["epsilon"] == "0.003"]
+    tab_75_003["mean_acc"], tab_75_003["mean_att"] = (
+        sum(tab_75_003["accuracy"]) / 10,
+        sum(tab_75_003["attack"]) / 10,
+    )
+
+    table_mean = table_mean.append(tab_25_001.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_25_01.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_25_03.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_25_005.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_25_003.head(1), ignore_index=True)
+    ###
+    table_mean = table_mean.append(tab_5_001.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_5_01.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_5_03.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_5_005.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_5_003.head(1), ignore_index=True)
+    ###
+    table_mean = table_mean.append(tab_75_001.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_75_01.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_75_03.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_75_005.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_75_003.head(1), ignore_index=True)
+    ###
+    table_mean = table_mean.append(tab_1_001.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_1_01.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_1_03.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_1_005.head(1), ignore_index=True)
+    table_mean = table_mean.append(tab_1_003.head(1), ignore_index=True)
+
+    print(
+        table_mean[column].sort_values(by=["epsilon", "percent"]).to_latex(index=False)
+    )
+
+    y_001 = table_mean[table_mean["epsilon"] == "0.001"]["mean_att"]
+    y_001_acc = table_mean[table_mean["epsilon"] == "0.001"]["mean_acc"]
+    x_001 = table_mean[table_mean["epsilon"] == "0.001"]["percent"]
+
+    y_003 = table_mean[table_mean["epsilon"] == "0.003"]["mean_att"]
+    y_003_acc = table_mean[table_mean["epsilon"] == "0.003"]["mean_acc"]
+    x_003 = table_mean[table_mean["epsilon"] == "0.003"]["percent"]
+
+    y_005 = table_mean[table_mean["epsilon"] == "0.005"]["mean_att"]
+    y_005_acc = table_mean[table_mean["epsilon"] == "0.005"]["mean_acc"]
+    x_005 = table_mean[table_mean["epsilon"] == "0.005"]["percent"]
+
+    y_01 = table_mean[table_mean["epsilon"] == "0.01"]["mean_att"]
+    y_01_acc = table_mean[table_mean["epsilon"] == "0.01"]["mean_acc"]
+    x_01 = table_mean[table_mean["epsilon"] == "0.01"]["percent"]
+
+    y_03 = table_mean[table_mean["epsilon"] == "0.03"]["mean_att"]
+    y_03_acc = table_mean[table_mean["epsilon"] == "0.03"]["mean_acc"]
+    x_03 = table_mean[table_mean["epsilon"] == "0.03"]["percent"]
+
+    l_25 = []
+    l_25.append(np.std(tab_25_001["accuracy"], axis=0))
+    l_25.append(np.std(tab_25_01["accuracy"], axis=0))
+    l_25.append(np.std(tab_25_03["accuracy"], axis=0))
+    l_25.append(np.std(tab_25_005["accuracy"], axis=0))
+    l_25.append(np.std(tab_25_003["accuracy"], axis=0))
+    # ###
+    l_5 = []
+    l_5.append(np.std(tab_5_001["accuracy"], axis=0))
+    l_5.append(np.std(tab_5_01["accuracy"], axis=0))
+    l_5.append(np.std(tab_5_03["accuracy"], axis=0))
+    l_5.append(np.std(tab_5_005["accuracy"], axis=0))
+    l_5.append(np.std(tab_5_003["accuracy"], axis=0))
+    # ###
+    l_75 = []
+    l_75.append(np.std(tab_75_001["accuracy"], axis=0))
+    l_75.append(np.std(tab_75_01["accuracy"], axis=0))
+    l_75.append(np.std(tab_75_03["accuracy"], axis=0))
+    l_75.append(np.std(tab_75_005["accuracy"], axis=0))
+    l_75.append(np.std(tab_75_003["accuracy"], axis=0))
+    # ###
+
+    l_1 = []
+    l_1.append(np.std(tab_1_001["accuracy"], axis=0))
+    l_1.append(np.std(tab_1_01["accuracy"], axis=0))
+    l_1.append(np.std(tab_1_03["accuracy"], axis=0))
+    l_1.append(np.std(tab_1_005["accuracy"], axis=0))
+    l_1.append(np.std(tab_1_003["accuracy"], axis=0))
+
+    x_acc = [x_001_acc, x_01_acc, x_03_acc, x_005_acc, x_003_acc]
+    x_sizes = [x_001, x_01, x_03, x_005, x_003]
+    epsilons = [0.001, 0.01, 0.03, 0.005, 0.003]
+    # example variable error bar values
+
+    for i in range(5):
+        yerr = [0.01, l_25[i], l_5[i], l_75[i], l_1[i]]
+        plot_figure(x_acc[i], x_sizes[i], yerr, epsilons[i], exp)