BayesianNeuralNet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5theVSlqFEMW"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import scipy\n",
    "import pandas as pd\n",
    "from scipy.stats import multivariate_normal\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.utils import shuffle\n",
    "from tqdm import tqdm\n",
    "import matplotlib as mpl\n",
    "mpl.use('Agg')\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "# Ignore warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import pyro\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Zm5rduc9FKmh"
   },
   "outputs": [],
   "source": [
    "es = list(range(4, 10))\n",
    "ns = [int(math.e**i) for i in es]\n",
    "\n",
    "N = max(ns)\n",
    "class_0 = np.random.multivariate_normal([-1,0], [[1,0], [0,1]], int(0.9*N))\n",
    "class_1 = np.random.multivariate_normal([1,0], [[1,0], [0,1]], int(0.1*N))\n",
    "\n",
    "\n",
    "orig_data = pd.DataFrame(class_0, columns=list(range(class_0.shape[1])))\n",
    "orig_data['y']=0\n",
    "temp = pd.DataFrame(class_1, columns=list(range(class_1.shape[1])))\n",
    "temp['y']=1\n",
    "orig_data = orig_data.append(temp);\n",
    "orig_data = orig_data[list(orig_data.columns[-1:]) + list(orig_data.columns[:-1] )]\n",
    "orig_data = shuffle(orig_data)\n",
    "\n",
    "\n",
    "# Create Test Data\n",
    "class_0_test = np.random.multivariate_normal([-1,0], [[1,0], [0,1]], int(0.9*1000))\n",
    "class_1_test = np.random.multivariate_normal([1,0], [[1,0], [0,1]], int(0.1*1000))\n",
    "\n",
    "test_data = pd.DataFrame(class_0_test, columns=list(range(class_0_test.shape[1])))\n",
    "test_data['y']=0\n",
    "temp = pd.DataFrame(class_1_test, columns=list(range(class_1_test.shape[1])))\n",
    "temp['y']=1\n",
    "test_data = test_data.append(temp)\n",
    "test_data = test_data[list(test_data.columns[-1:]) + list(test_data.columns[:-1] )]\n",
    "test_data = shuffle(test_data)\n",
    "\n",
    "#flipping\n",
    "flipped_data = orig_data.copy()\n",
    "def random_flip(row):\n",
    "    if(np.random.uniform()<0.3):\n",
    "        return int(not(int(row['y'])))\n",
    "    else:\n",
    "        return row['y']\n",
    "\n",
    "flipped_data['y'] = flipped_data.apply(random_flip, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Zw5Ybwpc5fF"
   },
   "outputs": [],
   "source": [
    "from torch.utils import data\n",
    "\n",
    "class Dataset(data.Dataset):\n",
    "  'Characterizes a dataset for PyTorch'\n",
    "  def __init__(self, dataframe):\n",
    "        'Initialization'\n",
    "        self.dataframe = dataframe\n",
    "\n",
    "  def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.dataframe)\n",
    "\n",
    "  def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Load data and get label\n",
    "        X = orig_data[[0,1]].iloc[index].values\n",
    "        y = orig_data['y'].iloc[index]\n",
    "\n",
    "        return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZZZWcjRCFcb3"
   },
   "outputs": [],
   "source": [
    "from torch.utils import data\n",
    "orig_dataloader = data.DataLoader(Dataset(orig_data), batch_size=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Pr9nMK4bFjOr"
   },
   "outputs": [],
   "source": [
    "class NN(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(NN, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        output = self.fc1(x)\n",
    "        output = F.relu(output)\n",
    "        output = self.out(output)\n",
    "        return output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = NN(2, 10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyro\n",
    "from pyro.distributions import Normal, Categorical\n",
    "from pyro.infer import SVI, Trace_ELBO\n",
    "from pyro.optim import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_softmax = nn.LogSoftmax(dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(x_data, y_data):\n",
    "    \n",
    "    fc1w_prior = Normal(loc=torch.zeros_like(net.fc1.weight), scale=torch.ones_like(net.fc1.weight))\n",
    "    fc1b_prior = Normal(loc=torch.zeros_like(net.fc1.bias), scale=torch.ones_like(net.fc1.bias))\n",
    "    \n",
    "    outw_prior = Normal(loc=torch.zeros_like(net.out.weight), scale=torch.ones_like(net.out.weight))\n",
    "    outb_prior = Normal(loc=torch.zeros_like(net.out.bias), scale=torch.ones_like(net.out.bias))\n",
    "    \n",
    "    priors = {'fc1.weight': fc1w_prior, 'fc1.bias': fc1b_prior,  'out.weight': outw_prior, 'out.bias': outb_prior}\n",
    "    # lift module parameters to random variables sampled from the priors\n",
    "    lifted_module = pyro.random_module(\"module\", net, priors)\n",
    "    # sample a regressor (which also samples w and b)\n",
    "    lifted_reg_model = lifted_module()\n",
    "    \n",
    "    lhat = log_softmax(lifted_reg_model(x_data))\n",
    "    \n",
    "    pyro.sample(\"obs\", Categorical(logits=lhat), obs=y_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "softplus = torch.nn.Softplus()\n",
    "\n",
    "def guide(x_data, y_data):\n",
    "    \n",
    "    # First layer weight distribution priors\n",
    "    fc1w_mu = torch.randn_like(net.fc1.weight)\n",
    "    fc1w_sigma = torch.randn_like(net.fc1.weight)\n",
    "    fc1w_mu_param = pyro.param(\"fc1w_mu\", fc1w_mu)\n",
    "    fc1w_sigma_param = softplus(pyro.param(\"fc1w_sigma\", fc1w_sigma))\n",
    "    fc1w_prior = Normal(loc=fc1w_mu_param, scale=fc1w_sigma_param)\n",
    "    # First layer bias distribution priors\n",
    "    fc1b_mu = torch.randn_like(net.fc1.bias)\n",
    "    fc1b_sigma = torch.randn_like(net.fc1.bias)\n",
    "    fc1b_mu_param = pyro.param(\"fc1b_mu\", fc1b_mu)\n",
    "    fc1b_sigma_param = softplus(pyro.param(\"fc1b_sigma\", fc1b_sigma))\n",
    "    fc1b_prior = Normal(loc=fc1b_mu_param, scale=fc1b_sigma_param)\n",
    "    # Output layer weight distribution priors\n",
    "    outw_mu = torch.randn_like(net.out.weight)\n",
    "    outw_sigma = torch.randn_like(net.out.weight)\n",
    "    outw_mu_param = pyro.param(\"outw_mu\", outw_mu)\n",
    "    outw_sigma_param = softplus(pyro.param(\"outw_sigma\", outw_sigma))\n",
    "    outw_prior = Normal(loc=outw_mu_param, scale=outw_sigma_param).independent(1)\n",
    "    # Output layer bias distribution priors\n",
    "    outb_mu = torch.randn_like(net.out.bias)\n",
    "    outb_sigma = torch.randn_like(net.out.bias)\n",
    "    outb_mu_param = pyro.param(\"outb_mu\", outb_mu)\n",
    "    outb_sigma_param = softplus(pyro.param(\"outb_sigma\", outb_sigma))\n",
    "    outb_prior = Normal(loc=outb_mu_param, scale=outb_sigma_param)\n",
    "    priors = {'fc1.weight': fc1w_prior, 'fc1.bias': fc1b_prior, 'out.weight': outw_prior, 'out.bias': outb_prior}\n",
    "    \n",
    "    lifted_module = pyro.random_module(\"module\", net, priors)\n",
    "    \n",
    "    return lifted_module()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "optim = Adam({\"lr\": 0.01})\n",
    "svi = SVI(model, guide, optim, loss=Trace_ELBO())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_iterations = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 1/20 [00:09<03:06,  9.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  0  Loss  2.688241181771451\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|█         | 2/20 [00:19<02:55,  9.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  1  Loss  1.2437119732312703\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|█▌        | 3/20 [00:28<02:44,  9.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  2  Loss  0.9694359728184138\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|██        | 4/20 [00:38<02:34,  9.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  3  Loss  0.8697841923285696\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|██▌       | 5/20 [00:48<02:24,  9.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  4  Loss  0.7640265142202554\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|███       | 6/20 [00:57<02:14,  9.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  5  Loss  0.6920861386128692\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███▌      | 7/20 [01:07<02:06,  9.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  6  Loss  0.5986790982581044\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|████      | 8/20 [01:18<01:59,  9.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  7  Loss  0.56430517981977\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|████▌     | 9/20 [01:27<01:48,  9.85s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  8  Loss  0.5645537788162877\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 10/20 [01:37<01:37,  9.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  9  Loss  0.582734988232184\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|█████▌    | 11/20 [01:48<01:32, 10.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  10  Loss  0.560835290524554\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|██████    | 12/20 [01:58<01:21, 10.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  11  Loss  0.5368737962636734\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|██████▌   | 13/20 [02:09<01:11, 10.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  12  Loss  0.5437979029670406\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|███████   | 14/20 [02:19<01:01, 10.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  13  Loss  0.5032721681746104\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|███████▌  | 15/20 [02:29<00:51, 10.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  14  Loss  0.5194673257473221\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|████████  | 16/20 [02:40<00:41, 10.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  15  Loss  0.4960786971346121\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████▌ | 17/20 [02:52<00:32, 10.92s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  16  Loss  0.524999288924386\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|█████████ | 18/20 [03:02<00:21, 10.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  17  Loss  0.5436136195304158\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|█████████▌| 19/20 [03:12<00:10, 10.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  18  Loss  0.5141672538742846\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "100%|██████████| 20/20 [03:22<00:00, 10.25s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch  19  Loss  0.5097796323122257\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for j in tqdm(range(num_iterations)):\n",
    "    loss = 0\n",
    "    for batch_id, data in enumerate(orig_dataloader):\n",
    "        # calculate the loss and take a gradient step\n",
    "        loss += svi.step(data[0].float(), data[1])\n",
    "    normalizer_train = len(orig_dataloader.dataset)\n",
    "    total_epoch_loss_train = loss / normalizer_train\n",
    "    \n",
    "    print(\"Epoch \", j, \" Loss \", total_epoch_loss_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils import data\n",
    "test_dataloader = data.DataLoader(Dataset(test_data), batch_size=64)\n",
    "flipped_dataloader = data.DataLoader(Dataset(flipped_data), batch_size=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction when network is forced to predict\n",
      "accuracy: 89 %\n"
     ]
    }
   ],
   "source": [
    "num_samples = 10\n",
    "def predict(x):\n",
    "    sampled_models = [guide(None, None) for _ in range(num_samples)]\n",
    "    yhats = [model(x).data for model in sampled_models]\n",
    "    mean = torch.mean(torch.stack(yhats), 0)\n",
    "    return np.argmax(mean.numpy(), axis=1)\n",
    "\n",
    "print('Prediction when network is forced to predict')\n",
    "correct = 0\n",
    "total = 0\n",
    "for j, data in enumerate(test_dataloader):\n",
    "    feats, labels = data\n",
    "    predicted = predict(feats.float())\n",
    "    total += labels.size(0)\n",
    "#     print(torch.tensor(predicted), labels)\n",
    "#     print(predicted == labels.values)\n",
    "    correct += (torch.tensor(predicted) == labels).sum().item()\n",
    "#     print(correct)\n",
    "#     break\n",
    "print(\"accuracy: %d %%\" % (100 * correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_samples = 100\n",
    "def give_uncertainities(x):\n",
    "    sampled_models = [guide(None, None) for _ in range(num_samples)]\n",
    "    yhats = [F.log_softmax(model(x.float()).data, 1).detach().numpy() for model in sampled_models]\n",
    "    return np.asarray(yhats)\n",
    "    #mean = torch.mean(torch.stack(yhats), 0)\n",
    "    #return np.argmax(mean, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = ['0','1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "style.use('fivethirtyeight')\n",
    "import numpy as np\n",
    "from scipy.stats import multivariate_normal\n",
    "%matplotlib inline\n",
    "\n",
    "def imshow(img):\n",
    "    \n",
    "    x = np.linspace(-5,5,500)\n",
    "    y = np.linspace(-5,5,500)\n",
    "    X,Y = np.meshgrid(x,y)\n",
    "\n",
    "    pos = np.array([X.flatten(),Y.flatten()]).T\n",
    "    rv1 = multivariate_normal([-1,0], [[1, 0], [0, 1]])\n",
    "    rv2 = multivariate_normal([1,0], [[1, 0], [0, 1]])\n",
    "    fig = plt.figure(figsize=(3,3))\n",
    "    ax0 = fig.add_subplot(111)\n",
    "\n",
    "    ax0.contour(X, Y, rv1.pdf(pos).reshape(500,500), 6, linewidths=np.arange(0.3 , 2, .5), alpha = 0.9, colors='blue')\n",
    "    ax0.contour(X, Y, rv2.pdf(pos).reshape(500,500), 6, linewidths=np.arange(.5, 2, .5), alpha = 0.3, colors='red')\n",
    "    \n",
    "    ax0.scatter(img[0], img[1], s=10, c=\"black\", alpha=1)\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import colors\n",
    "def test_batch(images, labels, plot=True):\n",
    "    y = give_uncertainities(images)\n",
    "    predicted_for_images = 0\n",
    "    correct_predictions=0\n",
    "\n",
    "    for i in range(len(labels)):\n",
    "    \n",
    "        if(plot):\n",
    "            \n",
    "            fig, axs = plt.subplots(1, 10, sharey=True,figsize=(20,2))\n",
    "    \n",
    "        all_digits_prob = []\n",
    "    \n",
    "        highted_something = False\n",
    "    \n",
    "        for j in range(len(classes)):\n",
    "        \n",
    "            highlight=False\n",
    "        \n",
    "            histo = []\n",
    "            histo_exp = []\n",
    "        \n",
    "            for z in range(y.shape[0]):\n",
    "                histo.append(y[z][i][j])\n",
    "                histo_exp.append(np.exp(y[z][i][j]))\n",
    "            \n",
    "            prob = np.percentile(histo_exp, 50) #sampling median probability\n",
    "        \n",
    "            if(prob>0.2): #select if network thinks this sample is 20% chance of this being a label\n",
    "                highlight = True #possibly an answer\n",
    "        \n",
    "            all_digits_prob.append(prob)\n",
    "            \n",
    "            if(plot):\n",
    "            \n",
    "                N, bins, patches = axs[j].hist(histo, bins=8, color = \"lightgray\", lw=0,  weights=np.ones(len(histo)) / len(histo), density=False)\n",
    "                axs[j].set_title(str(j)+\" (\"+str(round(prob,2))+\")\") \n",
    "        \n",
    "            if(highlight):\n",
    "            \n",
    "                highted_something = True\n",
    "                \n",
    "                if(plot):\n",
    "\n",
    "                    # We'll color code by height, but you could use any scalar\n",
    "                    fracs = N / N.max()\n",
    "\n",
    "                    # we need to normalize the data to 0..1 for the full range of the colormap\n",
    "                    norm = colors.Normalize(fracs.min(), fracs.max())\n",
    "\n",
    "                    # Now, we'll loop through our objects and set the color of each accordingly\n",
    "                    for thisfrac, thispatch in zip(fracs, patches):\n",
    "                        color = plt.cm.viridis(norm(thisfrac))\n",
    "                        thispatch.set_facecolor(color)\n",
    "\n",
    "        predicted = np.argmax(all_digits_prob)\n",
    "        \n",
    "        if(labels[i].item()!=predicted):\n",
    "            if(plot):\n",
    "                print(\"Real: \",labels[i].item())\n",
    "                plt.show()\n",
    "\n",
    "\n",
    "\n",
    "            if(highted_something):\n",
    "                predicted_for_images+=1\n",
    "                if(labels[i].item()==predicted):\n",
    "                    if(plot):\n",
    "                        print(\"Correct\")\n",
    "                    correct_predictions +=1.0\n",
    "                else:\n",
    "                    if(plot):\n",
    "                        print(\"Incorrect :()\")\n",
    "            else:\n",
    "                if(plot):\n",
    "                    print(\"Undecided.\")\n",
    "\n",
    "            if(plot):\n",
    "                imshow(images[i])\n",
    "        else:\n",
    "            plt.clf()\n",
    "            plt.cla()\n",
    "            plt.close()\n",
    "\n",
    "\n",
    "    if(plot):\n",
    "        print(\"Summary\")\n",
    "        print(\"Total images: \",len(labels))\n",
    "        print(\"Predicted for: \",predicted_for_images)\n",
    "        print(\"Accuracy when predicted: \",correct_predictions/predicted_for_images)\n",
    "        \n",
    "    return len(labels), correct_predictions, predicted_for_images\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction when network can refuse\n",
      "Total images:  1000\n",
      "Skipped:  899\n",
      "Accuracy when made predictions: 0 %\n"
     ]
    }
   ],
   "source": [
    "# Prediction when network can decide not to predict\n",
    "\n",
    "print('Prediction when network can refuse')\n",
    "correct = 0\n",
    "total = 0\n",
    "total_predicted_for = 0\n",
    "for j, data in enumerate(test_dataloader):\n",
    "    images, labels = data\n",
    "    \n",
    "    total_minibatch, correct_minibatch, predictions_minibatch = test_batch(images, labels, plot=False)\n",
    "    total += total_minibatch\n",
    "    correct += correct_minibatch\n",
    "    total_predicted_for += predictions_minibatch\n",
    "\n",
    "print(\"Total images: \", total)\n",
    "print(\"Skipped: \", total-total_predicted_for)\n",
    "print(\"Accuracy when made predictions: %d %%\" % (100 * correct / total_predicted_for))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preparing for evaluation\n",
    "\n",
    "dataiter = iter(test_dataloader)\n",
    "images, labels = dataiter.next()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Showing incorrect classfications with their posterior distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real:  1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x144 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect :()\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANwAAAC+CAYAAABeZmHQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztnXl8VNX5/9/n3slMZrKQPQGyQQjIYgQURRZxwyJ1r1rX+rVabNUW9ypata3Waq3iV1t3a6tt1d9XrVoXtFZRUBZBtsiSBEI2khCyb5OZe8/vj5NtkhkWCQOR8369eJHM3Dn3zM393HPO8zzneYSUEo1GEx6Mg90BjeZwQgtOowkjWnAaTRjRgtNowojjQJ+goaFBW2U0hyVDhgwRfV/TI5xGE0a04DSaMDLoBFdQUHCwuxCUQ7Ffh2Kf4PDu16ATnEYzmNGC02jCiBacRhNGtOA0mjCiBafRhBEtOI0mjGjBaTRhRAtOowkjWnAaTRjRgtNowogWnEYTRgZMcEIIUwjxtRDi3wPVpkbzXWMgR7j5wMYBbE+j+c4xIIITQqQD3weeG4j2NJrvKmIg0uQJIf4PeACIAW6RUp7R9V7vHd+H6rYMjWagyM3N7f452I7v/U6xIIQ4A6iWUq4SQpy4t535thQUFAxIOwPNodivQ7FPcHj3ayCmlNOBs4QQxcArwMlCiJcHoF2N5jvHfgtOSnmHlDJdSpkNXAT8V0p52X73TKP5DqL9cBpNGBnQNHlSyk+BTweyTY3mu4Qe4TSaMKIFp9GEES04jSaMaMFpNGFEC06jCSNacBpNGNGC02jCiBacRhNGtOA0mjCiBafRhBEtOI0mjGjBaTRhRAtOowkjWnAaTRjRgtNowogWnEYTRrTgNJowogWn0YQRLTiNJoxowWk0YUQLTqMJI1pwGk0Y0YLTaMLIfgtOCJEhhPhECLFRCJEvhJg/EB3TaL6LDEQiWD9ws5RytRAiBlglhPhISvnNALSt0XynGIjaAjuklKs7f25CFWUcvr/tajTfRQakPlx3Y0JkA58BE6SUjaDrw+0Ltg22LRBCYpoHuzeAbSP8ftUxACHANJGmqX7W9OOA14frQggRDbwO3NAltt115tsymGuLtbXBpk0mGzcabN1qUFJisGuX6L6fDQNMs0t40PUsHDJEkp4uGTnSZvRoiwkTLOLiBqZP2DY0NiIaGhDNzYjWVmhtRXi9qgMOh+oYqN8tS/1zuZAuF9LjgZgYZEwMMi4OnM6B6ddBIBz9GhDBCSEiUGL7u5TyjYFo87uAbcO6dQaffupg+XIHfj+MG2dzxBEW3/uen8xMm+Rk2X0/B0NKaGiAkhKDbdsMli518PTTLlpaYNIki5kz/Rx/vIXLtQ8da2nBqK5G1NQg6uuRbjdyyBAlmpQUpNsNkZFKbKG+WEcHoq0NWloQzc0YxcWIhgYlwqQk1U5CArv9cochA1EBVQDPAxullI/sf5cGP5s3G7zxRgRffulg/HiLk07y8+MftxIbu+9tCQFxcRAXZ5OXZ3P22X4AOjpg9WqTxYsdPPpoJKNHW5x7ro+pU63g93hHB6KiAqOsDNHRgZ2Sgp2ZiZw4ESIi9q1ThgGRkcjISIiPp3vN0Pl0MHbtwigoQLS0YKelYaens1dD8mHAQIxw04HLgfVCiDWdry2QUr43AG0PGmwbPvzQwUsvOYmOllx4oY9bbvHu8728tzidMHWqxdSpFlJ6WbvW4I03nDz0kIsf/MDHD37gUwc2NWFs24ZRXY2dnIw9dqwaeQ7EGqzz6WDHxUFODrS1YVRUYK5dCw4H9ogRyKFDB/68g4j9FpyUcglw2K6gpYRFixwsXJjLjBkmDzzQRnr6wBmi9gYhYOJEm4kT22lshNdec/I/F8AZoyrJOb0UIzcL/wkn7NX6akBxu7FzcmDkSMTOnRhbt0JBAREOB4wadVgaXvQEez/Izze4/HIPy5eb3HvvNu66yxt2sfUl1uNn3vS1vHL9x7RFRPODP8/l/cIxyIgwi603QiBTUrCmTsWeMAFXeTnmsmVqcXqYMaAVUA8XvF547DEX69eb3H13O6NH2xQU+Pf687YNJSWCwkKT7dsNKisF9fWClhaB36+WSG63JD5ekpwsSU+3GTVK/dvdFFXU1GBs2IBMSMA4eQYnjyrhgkQvf/iDizffjOA3v2knJWU3D4TWVkRjI6KlRf3c0QE+n7JKguqYw4GMiAC3G+nxIGNiIDZ2r40jMjGR5okTsT0eHKtWYQ8bhj169GFjXNGC20cKCgwWLIjkrLPUGm1v75Pt2wWffupg6VIHX39t0tQkME0YPtwmLU2SkGATFydxONT93dYGxcUGK1YYlJYaeL3KaHjkkRbHH+9n1iw/eXm2mpXZNsbmzYiqKuwJE5BJSd3nTUiQPPBAO0uXmvzkJx7mz/dy8smdDwefD1FVpYRaW6ueJF24XEinU01Du1Ru2+D3I1pbEVVV9PZnyCFDkElJ2Ckp7NE6JAQyPR1/Sgpmfj7m0qVYkyZBdPTeXcxBjBbcPvD++w6ee87JAw+oUW1PNDbC229H8OabEeTnmyQkSKZP93PrrV7y8ixycnY/YnVh21BaKsjPN1m1yuTddyP4859dDBtmc973m7l09AqShjuxpk8PaXGcPt3ir39t4fZfRlKwdBc/Pb0Is6ZaLUIjI7ETE5Hx8cjYWHXjh3IJdCGlGgWbmhD19YjaWoyCAoyCAmRUFDIjA3v48N2vG51OrEmTEKWlOJYvx5owAZmauucLMojRgtsLpISnn3by9dcmL77YSkzM7o+vqRG88IKTV16JwDDgjDN8LFjgZdKkECb7PWAYkJUlycryM3euH/BSVGTw0ZvtbPvHan7UlMmouSP42bW+0A8CKYlvqeCZS4p4558dPP37SK78VTYRWWnfzmQvBERFUdnczNJvvmH69OmkxsUhqqowKiowNm3CKCjATk/HHjlS+fVCIDMy8MfE4Pj6a+zWVuwRI/a9P4MELbg9ICU8+KCL5mbBn/7UttsHf3s7PPeck+efdzJkiOTGG72cd56PqKg9n6OpCZqaBD6fElh0tIowCRXilZNUx5jJq+i4cAwfb87kmWdMzj7bydln+7jpJm/AWk3U1GBs3IhobkbGxHDG3eN49bMM5i108sQTbeyheyGpqqpi7ty5FBUVkZOTw3vvvUdqZiZWZiY0NmIUF2OUlGCUlWGPGKGEF+oLxcXhnzoVc+VKDJ9Preu+g2jB7QYp4aGHXPj98Nvftu/Wir1+fRTXXRdFXZ1g/nwvl1ziCzqbsm1l3VyxwsH69QZbtpiUlRl0dPQ/1jQhLc0mJ8dmwgSLY46xOPpoC5e3EceqVVjjxmGkpTE708+pp/r5+GMHDz3kYu7cKG67zcukCX6MtWsxKiqQHg/WpEnItDQALrzIwh3l47rr3Dz1VFvgANTR0W04wedDWJa6GIaBdDiU0zsqiqVLllBUVARAUVERX3zxBeeee65qIzYWOy8Pe9QojC1bMAoLERUV2EceGfoiut1YU6dirliBIQT2IRj+tb9owe2G55930tAguP/+0GKzLHjiCSdPPJHD979vcdddXpKS+lsCN240eP31CD74IIKamp7GHA5IT7dJSZHExEicTollCZqboabGoLRUUF7u4LPP1J8qztXKVWPWkXfReKakpHb7dYSAU0/1M3Omn6efdrLwnjbOzSznF9f4cR85SvnD+sxnzzzTj9cruO1GBwsXlOBoawZQxpLo6O7YyO5gZdtWVsv2dkR9PScOG8bsjAy2lpYSNWIE06ZN63+BPB7siRORGRkYGzZgLl+Oa3d+OKcTa8oUzGXLEE4nMitrz3+oQcSA7hYIRu/dAgNBuAJfP/7YwSuvRPDkk6GnkU1NcNNNblauNLnmmmJ+9rOkgPelhKVLTZ580sWqVWoq5XZLZs60mDbNz6RJFiNH7t5wIiWUlQnWrTNZtlTQ9P4yNjZlsN2RQ2amzdVXd3Duub6ANkR5OdvfzufRJ91sT5rKH593MWJE/7WdqKtDVFfzt3+62eVIY/5d++6rq6qq4svPPmPm6NEkdwYzy+HDg08d/X6Mb76hcuVKhk6ciHXUUaGNM62tOJYtw8rLC7C6HkgG+t4KtltACy4I27cLbrjBzYsvtjJkSPBjamsFV13lprbW4OmnWzHNzQH92rrV4Le/dfHll+qGmjjR4pJLOpg924/b/e36Zaxbh+23+dJ7NK+84uSjjxzYNmRn29x5ZzszZ1oqjGvTJmRiIivsITzy+CSKigyee66VCROU6ERdHaKyUlklU1OxpeD6692ce66P2bP33p8YlJYWjPJypNOJzMwM6l/bvngxOW1tyNhYrClTQlpWxa5dmGvX4p82bbdGl4FCCy4IB1pwfj9ccYWHX/6ynby84Ba/+nr40Y+i8PngL39pJS1NdvfLtuGFF5wsXKjWfhMnWtx8s5cpU6w9nrexUdDRoQaH2FgZsANA7NiBsWWLMv13jgrbtwueeMLFO++oG/bqUzZzw6lrcY4Yip2XR0FREZmZudx4oxqF//Z8A+NdhWpXwNChAVO6hgb1nZ59tpWUZFuZ/Ftb1fTR7wcpkYah/HNuN8TEhDaAgBJeSQkyNVXFbvaioKCA0bGxmGvWIKOjsY47LuRIZxQWIurqlDAPMFpwQTjQgnvhBSctLfDznwexYqB8w1dc4aG2VvDyy63d1sCCggLS0nK59VY3n37qICZGsmCBl3PO8fVbqkgJ33xjsGOHgRBd+zolQ4ZInE61TGpsFPh8AilB+H1kFi0m+4KJOJL7m/BXrzZ59JZdxG1dg5mRxg1/O4LsET3XyueD2+e1Ub22mgdeH076iCA3t9/PV+/sZPGrtfzy6h3KOBIVpXYEOByqk5alok9aWhCtrcjoaGRyMnZaGqF8JaK8HOH1KlN/54Xo6peorsZcvRqZmIh19NHBo02kxPzyS+yMDGRGxm7+cvtPOASnjSa9qK4WvPOOg1dfbQ15zK9/Hcm2bQavvdYSYHqvr3dw660eNm0yOeooi4UL2xg6NPBZ09gIy5apSz5unMX48Xs3fTPyv6E5LpnPNyTh9cL48RYZGT1tT86p5a83Luf5N1J45Iuj+fIiwbPPtnZPXZ07K3jgDh+X3jmW624QvPpqS88Mra0NY+tWjB07OC4rgUXxmXzCGGaeuIdbw7aVw7uqCsdXXyHdbuyRI5EpKQGHyeHDkU1NGBs3Yo8ZEzAqypQUrAkTMNevx9i8GXvs2P7nEQJrwgQcX32FPy1t37cSHWIcHgFse8n//q+Ln/+8I2RwxDvvOHjzzQgeeaSNrKzeYoPbbx/Jpk0mp5/u46WXWgPE5vPBRx85WLPG5JRT/Jx2mn/vg5ybmzEqK/FMHs1JJ/mZM8dPba3g3Xcd1NcDloW5Zg3OaCdXPzWeW27z0dAg+PGPPRQWuhGlpWAYOEdn8fjjbVRXCx580KXCwbZswbF0KTgc+GfMwJo8mavuSeaxp2K7wydDYhjIhATssWPxn3gidlYWxubNmMuXK2tSb2JisHNyMDZtUnPnXsj0dPXZ4mJEdXXwc8XGYicnY3S6IAYzWnCdlJYKiooMTjop+KhTUyP47W8jufLKDqZP77kbfT647joP27er+MqHH24PEOzWrQaLFjmYOdPPCSdY+5yrxCgqws7ODniyH3WUzdy5ftauNdn4ZhGitRUrLw/hcnLVVR3cc087zc2CJxZEUl0b0e17S0uT3H9/O2/9vYPNzy5DtLTgnzFDjTydQ15amuSYYyw++MABXq8ysFRVISorETU10Nzck/uhCyGQQ4dizZiBnZaGY8UKxPbtgce4XNi5uRhbtvTEYHZiH3EEMiYGMz9fXdAg2Lm5GGVlBHVYDiL0lLKTv/5V3ayh/G2PPOJiyBDJL37hDXj9oYeUyf/oo+v43e8cAYL66iuzM7QruIirqgQff+xg5UqTkhID21bLHCnVv/TEVs4aUkf2VRPoG3chBMyaXE/tm9v4fNcIps5J7N6UePHFPprKGnn1zz6u/10OL7/c2q3XU46q4tqJ3/D718bx7FWJ/WwVoraWnx5fwVO/beIsUR/8epgmMj4eOzUVOWxYj8FDCGRWFv6kJMyvv0Y2NWGPH99jnHE6sbOycH3xBYwZ09OeYahp45dfYhQWBp9aRkZip6ZilJRgjxoV9HoOBrTgUJH5K1Y4uOMOb9D3i4oM3nwzgsceC4zIWLbM5KWXnAwbZnP77SU4HCMD3ktIkEFjG9evN3jySReNjYLvfc/Htdd2MHKkHSBWKWHXF4XkrxnK409Fs3On4MorOzjtNH/3/WsWFJAy1MA4aiT//reDM87ofM+ymHf6NhZ/PYpVq02eecbJddd1IGprMdes4cx7J/PYDzP517/aOf98NaKImhq146CxkSSHA8+wYeQzjLHHeJQjXAhlrWxrUwmHdu5UI9LmzdjZ2YFhW1FRKmJk1SqM9eux8/J6vlhUFFZ0NKK6OnC9FxeHnZ6uBJWdTTDfiZ2djeOrr5QTf5BuXtWCA/7zHwezZ/tCTveeecbJEUdYAT4qn08ZUAB+97t2oqN7ppnr1xvExvYXW0sLPPhgJBUVghtv9DJ+fOgdB0JAqr+cpMsnMSu2jaoqwZNPOvnnPyO477520uOa1HacUaOIS3EyfbrFxx87OPVUP0ZxMXbOCObfUM711yfw1FMuzpldT1bZGqyJE0lNjOfCCzt45hkn553djmNjvvKdeTwqYn/YMKZEO3llkYN75/Y8hLomknJ4Z9rR+nrMbdu6w7aso47qCYR2OLCOOQZz+XI1Lc7J6W7Hn5SEqK1FJiYGGFHsUaMwystV/4ONcjExSJcLsWtX2JzhA41ewwEffBDRGYXfn7o6wbvvRvA//xM43XzrrQi2bTOYO1cl7ul9fE2NwbhxgWLasUNw5ZUeJk60ePbZtt2KDVCWGOjeW5aaKrn3Xi833ODluus8fPNeORgGdmfoU0KCJDPTJn9Vh1Kr2018vJ/58734O2w+uD8fKydH3eTAFVd0UFniJ//ZFRjl5dg5OVgzZyrTu2ly7LEWq1c7+i63AomLw5o0SfnRpMSxfLnaJ9eFaWJNnoyxfTuiri7go3ZWFkZJSWB7bjd2WhpGeTmhrDb2sGGIHTt2f+0OYQ57wfl8UFZmkJMT/M56910HbrdkzpweQUqp4iyFoN+abskSkxNPDBRvTY3g2mvdLFjQznnn9ffLBcOoqQm6N2ziRJtnn27m7Sd3srFuaMB+s9GjberWluNN6/FXXXihj6MTt/LpFx6q3Nndr2cO93N57lJWfdKOdfTR/XZdm6ZyXWzYsOdbRCYkYE2bhoyNxfz6a8SuXT1vRkaqIOv16wONLW534G7yrrYyMro3xgY9V3IyRk3NHvt0qHLYC27DBpO8vNA28I8/dnDyyf6AqI/Vq022bTOYNctPdnbPTVRQYDBmjB0gKMuCm292c9ttXiZODC5q24Y1awxefjmCxx938sILTtZ+Uk97dGLQ41OddVz3k2buf3FEQCA0ts2xU/wsWd6z/okQfq6YvolvxHj+9a8eS6fxzTfMzKvjH1uOpSM+0HfWxdSpflascChhdCWGDYXTiXXMMcioKMw1awJ2j8u0NHC5EOXlgd87LQ1RWRnwmkxIUMeGchFERSGFUPPzQchhL7j16w0mTgwuOK8XvvrKwQknBI5YH3yglr7nnBNowi4qMvqt2155JYK8PIvjj+9/DinhvfcczJkTxUUXRfHUUy4+/tjBP//h4MnftXPSucN58klnP0u5qKkhPgGuvDWaBx5wBbzuSk+io6NHG6KigmPnxNJqxrBokeq3qKvDKCtj9NwsSrxprFsXZPHa0sJxQzay8/MCFS1SWYlRVKQMKzt2BBdfRIRKleD3K59bL+ycHIzi4sDjY2MRzc19vpzATkzE6D1K9r1ucXGIQZqA6LAX3ObNJqNHBxfcxo0GPh9Mnhz4/hdfOHA4YMaMHiF2dAjc7sCb0OeDV1918tOf9rd+Sgn33efi5pvdTJ/u5/33W1iypJl//auVj96u4eGFPv5nntrQesUVngBfsqivR8bEMOsUlXyosFD9GUVDAzIujrw8i/Xr1WtGRQVxRw5n/HiL/HyT+noVn4jLRcLUHIYNs1mzJlBworQUsXMnqTNzWNE4FpmdjczKwh41qttnZ2zcGNxnFh2t1mcVFWo/Xdf3TUxE+HzKj9ebrtzuva9NQoLyt4UaxWJiEH2d64OEw15wpaUGWVnBp3oFBSaxsZK0tB4htbSokWzMGCsg582mTZ5+I+XixQ5mzPAH3fH9l784efVVJ0891co993gDts+ItjZi0jz85CcdvP56C+XlBrff7u4ZtTp3bgNceqmP11/vnCpKCUIwdKikutpQCX8aG5FJSUyapPqWv8qHqKnBzswE0+zMONZzG4iKChWgnJ2N4TC6t8H1RsbH9zixg4x0dnY2gDJ+dDcssJOTlfO8d1sxMf0iU7q+W7/Rr+t9t1sFVg9CBkRwQog5QojNQohCIcTtA9FmuGhqCp1kqqJCkJERuCYrLlaXLDe3r8nf7LeVZ8kSsydDVi8aG+Hxx53ccIOXWbOCjK7t7cjORWN2tmThwrZuBzm2rea6nSqePt2vXocA35RhgNnSgoyOBqNnqlu5QVkL7U4fWEaGTXl5523g9ysx9/KPxcdL6uuDWHkiIrAzMhBlZf3fi4xU074+00I5ZEi/qaCMilK7y3vj8aj/29r6t93ZfkCGsUHEQFRANYE/AacD44CLhRDj9rfdcLE7i2FtrUFiYuATvMtIkZoa+HqwdrZsMTniiP6C+uwzB5YluOSSEGFKPl+A9XHSJIuJEzvDrTpDm2Rn6EiXMcff7u+3xcXwelV1GyA1VQmueUeLUmPnKJKYKKmrU50X1dXYfVKRx8ZKGoPWQkKtwUKIQgZbn0VF9T8+MlJV6ulNRIRytIcI45IOR8gQsEOdgRjhjgUKpZRbpZQdwCvA2QPQbljYneGtvZ1+VWlaW9XN6fHsOfi4rS14qsWSEjWN7XqQ90V05g/pzdixFiUlRo8ZvZfDODpa0lzvV6kQerfj7xFh17TW39rRfUMDREbK7sFCtLb267DTCV7vbp5KoZ5YLpcSRa8LLE2zX/AyDkf/14RQ3z+UEzDIum+wMBCRJsOB0l6/lwHHBTtwoAoyDmRhx7a23JDtNTZm0NRkUlBQ3P1aVVUsfn82lZU1FBT09hXF9munrS2XzZsL+m3zampKoqYmOeR5XWVlCK+X9l4CKi3NxOcTFG3dSkxFBa3R0fg61zH19TmUlG6joaWKjk71lJfHkpNtULJ9O20uF9u2ReH359DU0kR5aSmNnefesSMZrzeRgoICXGVldPh8agTppLY2k5KSKgwj+BTOVVxMsHcii4tx7dhBQ2Fh92tmUxPu8nJITe357lLiKinp18aQ8nK8EHANujBaW4kqL6fpABT43N97a0/76QZCcMEecUEf/4diQUaPxxOyvfR0F5s3mwHv79pl4nA4cDiSyc3tWfwtW1bVr50RI9xERY3utxVnzhyDv/zFjd8/hrFjg+QacbkQDQ3dWava2yE/P5p58zrIGTMGR1kZVkYGstM4IWUUR04eg1ns7A6hKi11YDu2MjI1FSs3l61bHTgcDlKyUhmespPUzh0IHo+T5GSH6ntyMqKtLaDCTUSEm3HjIhk+PMif1LYxpAyaXctoaUE4naT0ek9UV2PYNpvodS94vQiXKzBZkG3jKCzEzskJCAnrpr4es7kZa4A3IocjfcdATCnLgN5bcdOBigFoNywYRv8ZTRepqZLKysDnyfDhSiClpf0vXd9ZzqRJFitX9n+m5eXZHHWUxa9/HRl8t4nTqUzonTzyiErXcO65ndNBw0C0twOqRkFamo0wjYCoDSnBjorqNsOXlKj+JuSoh4SorQWgstIgOblTTHFxiPr6gHZqawUJCcGnz6KkBHvYsP5vSIlRW4vsY0USTU3Ivibbtjb6za0713kyRJVJ0WeNO5gYCMGtBHKFECOEEE7gIuDtAWg3LKSk9BdVF9nZyoLXe00/fLgkOlqSn28GrP+ystrZsiXwcp52mo9//7u/4ISABx9sY+tWg3nz3FRVBZ5fRkZCayttbcpX99JLTu6/v13FBQuB9Hi6LXtvvx3B974X+MToKghiu90IW+Unyc9XfcueNARcLrW3DLVfr7dLwh4xAmPz5m6jRHt70MB9ZZ3sTKfX772dO8Hr7ReaJmpr++U3EQ0N3W6A7te6rJahMui2talrNAjZb8FJKf3A9cAiYCPwmpQyf3/bDRcjR9oUFQW/DOPGWViWcoB3YRjKEb5zpwj43NChHd2jSBfZ2SpHyZo1/dvPzpa8/HIr1dUGs2dHc+utkbz+egSLF5u8uziO//eij1NPieLttyN4/PE2TjutVyxnbCyioYHGRvjwwwi+/30lDul0QkcHq1aZTJqkjreTk5HllSxfrvKs5I5BmfOrq/HX1LNpk8nYsb0sqZGRKmp/61Zav9lOrKvX08a2u7M4Exmp9sL1RUqMwkJVxri34LxeJa7EwHA14fX2y8glGhrUgyVUnpTm5kFb+GNA/HBSyveklKOllDlSyvsHos1wMW6cisAIxtChkmHD7O48JF3MmqVu5vffD3zd4ei/Ifm227zcf38knTPAAEaPtnnrrRbuuaed2lrBAw+4uOYaD3f8KoZvtnr48YW1fPhhM6ee2ictQUICeL088msfV1/t7bakyuRkRFUVtbWie5eMnZFBwUdl1NdKTjjBrwx8I0ZAZCTF//oGX7vVP6OY04k9Zgz5O9M4LqOsu0iHsW2bcmAfcUTI7THGtm1q/dknGNooLcVOTQ10XVhW0MRBYtcuJbYQmbxEY6MqOjIIOewjTSZPtrqTtPZFCCWu//438A9/+ul+HA54/fWIgPXftGn+7gzJXYwYYXP++T4WLIgMuuMkIgJ+8AMfzz/fxldfNbNhQxNr1zZx90I3V59bGbTOhkxK4pNPHEQ3V3Hmmb06EBVF8Ya2wHjOuDgWLR3CcKuEs87qXBc6HFhHHsmGZW2cMXQlQ1ODh7atzI8h+6QM7NwueghJAAAVTklEQVRc9a9re08IV4DYsUMlAxo6NHD06+jA2L5dbVLtfXxlZbcDvhuvV4WuJScHPQeWpQQXKmHoIc5hL7i0NOX4DRXUcPrpftatU7sDukhIkMyd66Oy0ujOCQlqZhQVJamuDrwhf/hDHyNH2txyS/CRrjddGelkiABeKeG5vw9hZVESN/9wa8C97/dD0a54RiX0fG7bNoOXVuVxfMImZhzTE9Hhi0viH+snMjuvAvOrr4JGbnzxhSNo0HUwRHEx5tq1KuyrT/0AY+NGZVzpvSaTEtHY2C/Mpyswuq8Dvvv92lo1uu2pnNYhymEvOIBp0yyWLAn+B5wyxSI72+bvfw9Mz/bTn3ZgGLBwoat3jC7HH2/xxRdmP8vn9der5EOXX+5h7dq92GOWkqJCo3o1VFkpuO46N5WVgvl/TCbC2xIQPrVokYPjz0sK2KD50EMuGoll1pXpONev6TalfvSRg/zmbCZfNR5RV4dj6VJlCOm0BO3cqZQcykLZTVMT5sqVmBs3qrR3U6YEOOVFaWnPFLMXYseO/qKSEmP7dlXTINT6rbJyUNeQ04IDzjzTx1tvhUi3LdTu6P/7v8AiHCNH2lx8cQdVVYJHHgk0X8+Z4+eddyL6RbGcf76Phx5q509/cvHzn7tZscIMHTAREYFMSEBUVVFUZHDffS6uv97NJZd0cNddXszMYcra2Jk67rPP1L4+t0dl0BLl5SxePIRPPnEwbpzFST/JVMevW4dtSZ5+2sncuT4SjxqG//jjkZGRmOvXY372GcbWrXz4Rjtz5oQIn/L5EJWVmKtW4ViyBFFfjzVuHNbkyYFiq67GLCjo/7rfr6L9+8yXRWUlorW1O/i5H5aFUVWlEs8OUnTm5U4uusjDY4+19YuRBGUImTMnihNO8HPvvT1Tr6YmOOusKHbsMLjjjkKuuKLnydvYCB9/HMGZZ/qCzn7WrjV49VUnGzaY5OZaHHGETWqqCvfq6FAxm1Vrd9L09TZ2jpnGD37g46ST/AF5V0RxMebGjXzecRypRyYxcmSPencsLuKc67NokfG89lqLSvlg25irV/PZkgh++szxvP1ue49LQEpVTLG4GGrr+P3vXfziFoknJUpV0DEM5f/qSoEOKvVderoSSB+/mKiowNy4Ef/RR/cTVukHH5BxyimBSV1tG/Pzz1UGrxkzgq4TRVkZRmUl1jHH9L+gA4BOdR6EAyW4t992sGWLyS23BA9heu89Bzff7OaVV1o46qieG3vNGoPLLosCOvjnP30ceWTPe+3tarPq9OlWj3O5D7YNhYUGW7YYVFcbtLaqezcpSTJyhJ+8mk8xj8lDxsf3+2xHu82ahV8wZozNkLOmd48idXWCSy+OxNy0gQvuHsWPftxz7sZ6m5tO3crJk3dxycNjg26V+OyDDr7+sJYbr9ypxNW1o9XhALdb1SZISFB96isMy1KbVHfuVCNbXx9bcTFFu3Yx8uijA143CgsxCgqwpkwJaQE1lyzBHjMmtEFlP9GCC8KBEpzfDxdc4OH559uCrlukhGuucVNaavDGGy0BzuA33ojgttscJCaaPP98T5Wars8tXarWdCecsO8lh0VJCUZVVb9iFmvWGFRUGJx2dDWRq5djZ2Zijx9Pba3gxz92s2mTyWknlvH49WXIsUeoXJISbrstkhUrHLz39CaGlG/GHj5chU91jjZSwsUXe/jDH9oC0qnvVV+rqlTlniFDVD7KPmnJRVkZOBxsaWoK/BvW1+NYtgw7LQ174sTgbXfuOLemT9+nPu0L4RCcXsN14nDAVVd18Kc/BQ8ZEgLuu6+dhgbB3XdHBqzPzjvPx7x5FTQ0CH70Iw+ffmoGfG7GDIvJky0WLXKweLG5T8mDZXq6msbV1CClyqfy3nuOTkupH0dqgooOKSmhbHklF1/s6U65/rP51cjcUSrdgc/Ha69F8O9/R/Dgg21EHZGOf8YM8PlwLF6snNlNTbz/vlrz7bXYfD5EaSnmkiWqpvf48Uo0fcW2fbsSfd/1V0eHsm5GRiqRBsO2lbvhO1CG2Lz33nsP6Am8Xu+AnqC2tpbExODJdfaX3Fyb555zMXZs8ClgVBRMmGDxxz9GYhgEOIxTUsoYPz6ejz+O4O23I/B6BVOm9KQ2d7lU+ykpki+/dFBYaFBWJoiJ6R9K2JvmFsGGrTFUfbyJ9Y3ZjB4jmTjRDtjsascnsPStBl64u5KCumTOudjk/vu9NDTUkpiSgoyPZ93/28qdv43j2hvh7LM7LZ8Oh6oPN3QoorGRjjWb+efvq7nlp7W4RAfdqaC7po1diWDr6zE6Rxxz0yaElNgjR6pckn2/jG1jFBRAXFz3xtbuv6FlYa5ahWhpUeuyEKFcxtatCMs64CWIB/reioyM/HXf1wanM+MAIQTcfXc7d90VGZAevDfHHWfxm9+0s2BBJNHRkssv77HknX++j6wsm5tucvPss04++cTBXXe1B+St9Hjorl/g9aqwsb5JfAKzyUnGT0skPjUK6dmInTIm4NjiYsHvfhfFl4tnMM1ewsMXfs6MGyaD2WOoWLUukqsfmszlJxdwzWkdSJkVuPZyu7HHjOH+fxzJMfPqiU2tgp07VdSI16uEJqUaoZxO8HiQMTHYmZnISZNC+8Tq6zEqKlRkS9+ATNtWKfXq6rAmTuxnWOmmuRmjuBj/8ccHf3+QoQXXh9xcm9mz/Sxc6OLWW4MbUM47z0dLC9x/fyStrYJ583rmiFOmWLz9dgv33efqTCDrYfp0P/PmdXDssVbAfe5y0Zk6b8+bKa1x43B88QUyKQmZmMi2bQbPP+/kX/9S0S5H5lnc8qs8jqhbhli5UhksUO6CX/zCzSmn+Jn/0DBka1N3hdTeqRT++18H1TtNzrjXgy1GfLuL10VbG0ZpqSphNXZsP8OK8Psxv/oKsWuXyvQcwsndVRnIys3d/TRgEKGNJkGwbfjZz9ycf/7uS/C+/noEd9+tquZceukGJkwILDKxfLnJww+7WL9ejWA5OTZnneXjtNP8ZGfbu03vEIzazbvY9Eo+L2yZxZJVKng3NVUVGDnnnM5U7e3tmCtXQnMLTy8dzqNvTuOCCzr41a+8gS6FmhrEzp3I2FiKvUOZf1M0L77YGnKg2Svq6zGqq7vznQQd+ZqbqXznHdLj41X97mAB0J0Y69aBbYc0pAw02koZhHAIDpQf7corPfz61+0BVse+fPmlyY03uomObuHPfxb98lJKqZIJvfSSkyVLelKHp6XZTJqk/G+ZmTZpaZKYGElEhMS2BU1NsGuXQWmpYPNmk7VrTQoLDbL8RQyzy2g68jgu/pFy2vfdGlZX7efF+Zso+qKK71+dwpzbxiBcwY1BDaWN/Oonjdw4v52ReW4VGL23RcgtSxVlrKsDy0LGxqookBCmWFFairlxI+WVlaSdcUa/rTq9MbZuVfUKpk4NWxiXFlwQwiU4UJs7f/5zD48+2hbgVO7Ljh2C667zs2VLHNdc4+XqqzuC3rPV1YJFixx8+qmDVatM2tv3fogzTVX5dOZMP2ePXMuIpEZlaOhdUVQqf+KDD0bicdss+OF/OC2rSQUrjxmjinD0Glabm2HePA/XXNOZPay5GVFb2z+pT9dn+t4rhoGMi1OhWLsrfNfcjLlxo7K0Jiay2eNh1IQJIQ8XpaXKBTB1ar+tOwcSLbgghFNw6nwGt9zi5o9/bGPUqNCi27y5gFWrxvHooy48Hrj+ejXNC1Uh1+9XDu+CAoOyMoOdOwVNTQKfTw0QUVGQlGQzfLgkJ8dmzBirZxkjJca6dYh2VRdAmg6WLjV57DEX33xjctllHfziF14qKgrITU3FzM9XEfixsdi5uciUFBob4dprPVx6aQenn76H0sfdCTH3cQ7c1qayNXf636zcXGRmJgWFhSH/hqKkBLOoCP+xx4begHqA0IILQrgFByrx6003ubnnnvZ+WZj79quurquslJOEBMmll3Zw3nk+kpIG+DpLiW91Pis/auF/l09jzUYPp5zi58Ybvd0Phu5rJSWiokKVlWptpdYXw53PjeGca5M4Zc4A11mTUlVNLSnBqKxU++fS01URxc6Ne6H+hkZhIaK8fLcuggNJOASnrZR7QU6OzdNPtzJ/vpsf/tDHeeeFzokYHy9ZsEBNK19+2cmLLzp57DEX06b5OfVUPzNm+IMn5NlLGhrUtpn//tfBf/87lfTWAs49+jPue/lIRh0TYlOmEMjhw7GGDmXjfyr55+93cPP5qxklQK5OVrvCk5L2fu3WF8tSItu5U5UnbmtThpOsrJDFFft+3li/XvnjjjsurNPIcKNHuH2gtRXuuSeSiAi48872gIdwqH75fPDppw7ee8/B5587aG4WDBtmk5dnMXq0TVaWzdChkoQEFbgcEaE2Qre2Qn29oLraoKRETT3z800KCgxME6ZM8TNnjp85c3zEtVVi5nfWf8vq8bH17pNtw9/+FsEHH0Tw8MNtpEfXYVRUYFRV0bVJT7rdEBuLjI5WP7tcyu/WZQSxbYRlqU2i7e1qzdfUpCL/O3NpyqQktQE1NTXkui7gWjU2qkiT2FjsCRN2vxY8wOgR7hDD44GHHmrnzTcjuOwyD7/8pTfAqR2MiAiYPdvP7Nl+fD5VHmvVKpMNGwzefTeCkhJjt0mEDQOGDbMZOdLmlFN83HyzxdFHB9Y1kEPS8MfEYK5bB9XVWOPHB0zJtm8X3HtvJGPH2vztb62dVs047Lg47HHjoLFRGUvq6xGNjcq0vzcPYpdLOcBHjkTGxyur494KxrYxtm3DKC5WBp309L373CBHj3DfkooKwW9+E0lMjOSWW7w0Nm75Vv2ybTWS1dUJWlrAsgRCSNxuNT1NSJB7bxWXEqO4GGPrVuzMTNY223y65Eg++8zBggXe7oIee9MObW3Q0aG25HTlhjAMFQ4WEaGmid/SXL9t+XJGeb3g8aiHw7edyg4weoQ7hBk2TPLUU218+qnJtde6yc0dyq23in61CPaEYahd1XvcWb03CIE9YgRt8Wl88mQRn79RzZSLo/jHS0OJiNyHqZoQajj3eIJn9P223autxSgsxF1UhH3KKYN65/a3RQtuPznxRIuZM1t57rk25s1LYcIEm0sv7ejnAA8HO3cKXnstgkWLopg7dwgXLVzJRM9OxNLN2BkZKvoj3KOJbautNdu3Q0cH9siRNA0ZQtphKDbQghsQTBNOPrmen/wkmc8/N3nkERcNDYK5c1UYV7Bd5ANFU5OqxvPOOxHU1wsuuMDHa6+1EBkJBQUeFYfY0oKxfTuOpUuVcWLoUBVHGSKz8X5j28pquWMHRlWVOufIkeqcQsABqAkwWNgvwQkh/gCcCXQARcCVUsr6gejYYMQwYNYsi1mz2qipEXzwgYNf/jKStja1VWfKFD95eTbx8d9egG1tkJ+vDC/Llpm0tAhmzvRz661ecnJCjKpRUdjjxmEfcQSiulrlI9m8GenxqCDm+HiVdu7bCtCyoKlJbduprVWZtTweZFoa/mnTDpk12qHA/o5wHwF3SCn9QogHgTuAX+5/twY/SUmSyy7zcdllPpqaVK3wFSscvPCCSX29IClJuQRSUyVJSSqOMjJSGUhUzUUVT1lba1BVJSgtNdixQ+B0quS1kyZZPPigj5SUfRCvYSDT0pBpadi2raySu3ZhbN/ek+04Kkq5BCIjVS4T01RPkq5SqJalDCldroGWFkR7u/pcXBx2Whpy/PgDN3oOcvZLcFLKD3v9ugw4f/+6890kJkbtgevaBycl7NrVI6LaWkFlpYHXK7AsdW+7XEqEiYk248ZJ0tNthg2T+5yiISSGofKS9A4gbm9XOUxaW1U8ZXu7qjHXFXEthLJMRkSovCbJyargY1RUyIBlTSAD5hYQQrwDvCqlfLn3673dAgNZ102jORTp7Vb4Vm4BIcR/gGCJAO+UUr7VecydgB/4+9525ttyqPjh+nIo9utQ7BMc3v3ao+CklKfu7n0hxBXAGcAp8kB70TWaQc7+WinnoIwks6SUrXs6XqM53Nnfle4TQAzwkRBijRDiqQHok0bznWV/rZSj9nyURqPpQttyNZowogWn0YQRLTiNJoxowWk0YUQLTqMJI1pwGk0Y0YLTaMKIFpxGE0a04DSaMKIFp9GEES04jSaMaMFpNGFEC06jCSNacBpNGNGC02jCiBacRhNGtOA0mjCiBafRhBEtOI0mjGjBaTRhRAtOowkjWnAaTRjRgtNowogWnEYTRgZEcEKIW4QQUgiRNBDtaTTfVfZbcEKIDGA2ULL/3dFovtsMxAj3KHAboCvnaDR7YL8KMgohzkKVqZovhCgGjpFS1vQ+Rhdk1BxOHNCCjMAC4LRv05lvy+FczG9fORT7BId3v751QUYhxJHACGCtEAIgHVgthDhWSlk5oL3UaL4jfOtyVVLK9UBK1++hppQajaYH7YfTaMLIfhVk7I2UMnug2tJovqvoEU6jCSNacBpNGNGC02jCiBacRhNGtOA0mjCiBafRhBEtOI0mjGjBaTRhRAtOowkj+7U9Z2/ovT1HozmcCLY9R49wGk0Y0YLTaMLIAZ9SajSaHvQIp9GEES04jSaMDGrBHWr5MIUQfxBCbBJCrBNCvCmEiDuIfZkjhNgshCgUQtx+sPrRGyFEhhDiEyHERiFEvhBi/sHuUxdCCFMI8bUQ4t8H8jyDVnCHaD7Mj4AJUso8YAtwx8HohBDCBP4EnA6MAy4WQow7GH3pgx+4WUo5FpgKXHeI9AtgPrDxQJ9k0AqOQzAfppTyQymlv/PXZajESgeDY4FCKeVWKWUH8Apw9kHqSzdSyh1SytWdPzehbvDhB7dXIIRIB74PPHegzzUoBdeZD7NcSrn2YPdlN/wYeP8gnXs4UNrr9zIOgRu7N0KIbGASsPzg9gSAhaiHt32gTzRgOU0GmoHMhzmQ7K5fUsq3Oo+5EzV9+ns4+9aLfhEOHEIzASFENPA6cIOUsvEg9+UMoFpKuUoIceKBPt8hK7hDNR9mqH716t8VwBmojNQH6yYvAzJ6/Z4OVBykvgQghIhAie3vUso3DnZ/gOnAWUKIuUAkECuEeFlKedmBONmgd3wfSvkwhRBzgEeAWVLKnQexHw6U0eYUoBxYCVwipcw/WH3q7JcA/grUSilvOJh9CUbnCHeLlPKMA3WOQbmGO4R5AogBPhJCrBFCPHUwOtFpuLkeWIQyTLx2sMXWyXTgcuDkzuuzpnNkOWwY9COcRjOY0COcRhNGtOA0mjCiBafRhBEtOI0mjGjBaTRhRAtOowkjWnAaTRj5/1kAYcUM9OocAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real:  1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x144 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect :()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real:  1\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQ4AAACZCAYAAABufKdoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAFu5JREFUeJzt3X2w7HV9H/D3R64Qjcz1gVopl4aruVbRpIoIJmY0RkVkUq6ORHBixMZEbUJra22qQ+IwmpYoprSpjCYa41MsoOPD1SL4EEzTJCiJz0Bvzg2iXPE59raT4gPx2z92D1nOb885u/ee3T27+3rN7HD2t9/f9/f5/d67M3c+/B6qtRYAAAAAgEF3m3UBAAAAAMD2o3EIAAAAAHRoHAIAAAAAHRqHAAAAAECHxiEAAAAA0KFxCAAAAAB0aBwCAAAAAB0ahwOqaldVfauqds26liSpqh+pqm9W1fGzrmUZVNWpVfWVqvrhWdeSJFX1E1X1paq656xrAQAAAJbPQjYOq+qsqvp0VX23qm6pqhePuOrFSd7eWjs4MNexVfWGfkPxb6vqg1X1oE22/+aqakNeP6iq+/fHXLTOmFZVj06S1toXk1yZ5JWHdySWT1U9rqreV1Vf7B/LXx9j9UuTvLq19rcD8x1fVVdW1f/pvy5fzXCDGv55VV1bVd+oqv9bVX9ZVT+/Zswjq+pjVfW1/vf0S1X12qq69+qY1tqfJ/l8klG/vwAAAABbZuEah1V1apL3Jbk6ySOSXJTkP1bVCzdZ7/gk5yb5vTUfvS3JE5Ock+SnklSSD1fVPTaY7kVJjl/z+niSa1trX++Pec2QMe9KciDJXwzM9cYkz66q4zaqnzvdK8mNSX4tyVdHXan/vXl0krcMLLtbkg8k2Z3kyUnOSPLgJO+tqtpguicm2ZfkrCSPTHJ5krdV1bkDY76b5M39OfckeV7/7z9YM9cbk/xqVd191H0BAAAA2ArVWpt1DVuqqt6R5KTW2k8OLLskyTmttd0brPevk/xKa+3BA8senGR/kqe01j7UX3af9BpSL2itvXnEmlbneWZr7Z3rjNmZ5LYkF7XWLlnz2ReTXNxae/0o26Onqm5J8sbW2m+OMPY/Jzm5tXbGwLIzklyT5CGttf39ZQ9L7yzAJ7TWPjZGLe9P8r3W2jM2GPOi9PK/z8CyH0pyKMne1trVo24PAAAA4Egt3BmHSR6b3tmGg65OctIm9y58fJJPDJnr+0k+urqgtfbt/rifGqOmFyT5epL3bjDmOUl2pHcW2lofT/KEMbbH+NbL/wurTcMkaa3dkORgxss/SXYm+eZ6H1bViemd1Xrt4PLW2neSfCbyBwAAAKZsERuHx6d7iepXBz5bz+4kXx4y1zdba383ZL6RHlhSVcckOT/Jm1pr399g6POTvLu19o0hnx1M8sBRtsdhWy//YZc7j5x/klTVs5M8JsnvDvnsz6rq9iRfSvLtJD+/dkzkDwAAAMzAIjYON7LRddn3SPKdLZpr0DlJ7pvkDesNqKrHJnl4hjSW+r7Tr4/JmUj+VbU3veyf11r75JAh5yY5Jckz0rvX4bDL0eUPAAAATN0iNg6/kuQBa5b9w/5/N3pYxjfSa/Ctneu4qjpqyHyjPnjjhUk+1Fq7eZMx+ze4Z959+/UxOevlv/a7lIyYf1Wdl+SKJM9vrb1t2JjW2q2ttZtaa+9O8otJnlNVD1kzTP4AAADA1C1i4/BPkzxlzbIzk3yxtXZwg/U+meRhQ+a6e5KfWV1QVfdOcnqS/7lZIVV1cnr3wlvvTMJU1X3TOytx3TFJfix3fdIyW2+9/HdX1Z7VBVX10CQnZpP8q+qX07tf5fnrNQ2HWP09HrNmufwBAACAqVvExuGlSU6rqv9QVQ+pquck+ZdJfmuT9a7qr3fnJaGttb9K8r4kr6uqx1fVI5K8I7174V2xOq6q3lpVbx0y5wvSO2vt/Rts9/z+f98y7MOqOjbJo5L8903qJ0lV3auqHtHP6ugkD+i//9FNVr0qyePWLPtIeg3Ft1fVaVV1epK3JbkuyR8PbPOjVXXxwPt/k+R1SV6U5I+r6gH9130HxvxSVZ1TVQ+tqt1V9c/Su6T5U0k+NzBuT3r3U/zguMcCAAAA4EgsXOOwtXZ9kqcl+dn0nkb7yiQXttaG3Ttu0IeSfC3J09cs/4UkH0vyniR/lt4xO6O1dvvAmH/cf92p34B8TpLfb63dscF2n5/kXa21v1nn83OS3LLBZczc1anpNd8+lV7D7Vf7f79xk/X+MMn9q+onVxe01n6Q3vfoS+k9WfvDSf46yd7W2uA9Dh+Uuz4s5UVJjkrvfoVfGXi9e2DM3yW5ML0nZt+Q5DVJ9iV5cn+7q56d5MObXOoOAAAAsOXqrv2P5VZVv5DkxUlOadvgwFTV3dJrfv5ma+2KzcZzZKrqN5I8qrX2tFnXkvTOnkxyIMnTWmvXzboeAAAAYLks3BmHR+jt6V2K/I9mXUjfCUnerGk4NZck+cuq+uFZF9K3O8mvaxoCAAAAs+CMQwAAAACgwxmHAAAAAEDHjmlt6NChQ05tnDM7d+6srZhH9vNH9stN/stL9strq7JP5D+P/PaXl+yXm/yXl+yX1+Fk74xDAAAAAKBD4xAAAAAA6JjbxuHKysqsS9iUGrfOvNSZzE+t81LnduTYLTf5Ly/ZLzf5Ly/ZLy/ZLzf5Ly/Z39XcNg4BAAAAgMnROAQAAAAAOqb2VGWm49jbHz3mGu+YSB0AAAAAzDdnHAIAAAAAHRqHAAAAAECHxiEAAAAA0KFxCAAAAAB0aBwCAAAAAB0ahwAAAABAh8YhAAAAANChcQgAAAAAdIzUOKyqM6tqf1UdqKqXrjPmmVV1Y1XdUFXv2NoyAQAAAIBp2rHZgKo6KsllSZ6c5GCS66tqX2vtxoExe5K8LMljW2vfrqr7T6pgAAAAAGDyRjnj8LQkB1prN7fWvpfk8iR714z55SSXtda+nSStta9vbZkAAAAAwDRtesZhkhOS3Drw/mCS09eMeXCSVNWfJjkqyUWttavXm3BlZWXMMic7zyRNu8ZTdo2/zmCNe/bs2cJqNt7WNNedtnmpdV6y344WbX/kP55F2h/Zj2eR9mfS2SeLdbySxdofv/3xLNL+yH48i7Y/8h/PIu2P7MezSPtzpNmP0jisIcvakHn2JPnpJLuS/ElVPby19r+HTbgVX9iVlZWp/IP3SMykxtvHX2WaNR7utuYh71XzUuu065yHYzKqecl4O1mk4yX/8SzSsZL9+BbpeMl/PIt0rGQ/nkU6VrIf3yIdL/mPZ5GOlezvapRLlQ8mOXHg/a4ktw0Z877W2vdba19Isj+9RiIAAAAAMIdGaRxen2RPVe2uqqOTnJdk35ox703yhCSpquPSu3T55q0sFAAAAACYnk0bh621O5JckOSaJDclubK1dkNVvaKqzu4PuybJt6rqxiTXJvl3rbVvTapoAAAAAGCyRrnHYVprVyW5as2ylw/83ZK8uP8CAAAAAObcKJcqAwAAAABLRuMQAAAAAOjQOAQAAAAAOjQOAQAAAIAOjUMAAAAAoEPjEAAAAADo0DgEAAAAADo0DgEAAACADo1DAAAAAKBD4xAAAAAA6NA4BAAAAAA6NA4BAAAAgI4dsy4A2BrH3v7oMdd4x0TqAAAAABaDMw4BAAAAgA6NQwAAAACgQ+MQAAAAAOjQOAQAAAAAOjQOAQAAAIAOjUMAAAAAoEPjEAAAAADo0DgEAAAAADpGahxW1ZlVtb+qDlTVSzcYd05Vtao6detKBAAAAACmbdPGYVUdleSyJE9NcnKSZ1XVyUPGHZvkXyX5+FYXCQAAAABM1yhnHJ6W5EBr7ebW2veSXJ5k75Bxr0zy6iTf2cL6AAAAAIAZ2DHCmBOS3Drw/mCS0wcHVNUjk5zYWvtAVb1kswlXVlbGKnLS80zStGs8Zdf46wzWuGfPni2sZuNtTXPdaZtFrYuc/Xa0aPsj//Es0v7IfjyLtD+Tzj5ZrOOVLNb++O2PZ5H2R/bjWbT9kf94Fml/ZD+eRdqfI81+lMZhDVnW7vyw6m5JLk3y3FE3uhVf2JWVlan8g/dIzKTG28dfZZo1Hu625iHvVTOrdUGz347m6fu4XSzS8ZL/eBbpWMl+fIt0vOQ/nkU6VrIfzyIdK9mPb5GOl/zHs0jHSvZ3NcqlygeTnDjwfleS2wbeH5vk4Uk+VlW3JHlMkn0ekAIAAAAA82uUxuH1SfZU1e6qOjrJeUn2rX7YWjvUWjuutXZSa+2kJNclObu19hcTqRgAAAAAmLhNG4ettTuSXJDkmiQ3JbmytXZDVb2iqs6edIEAAAAAwPSNco/DtNauSnLVmmUvX2fsTx95WQAAAADALI1yqTIAAAAAsGQ0DgEAAACADo1DAAAAAKBD4xAAAAAA6NA4BAAAAAA6NA4BAAAAgA6NQwAAAACgQ+MQAAAAAOjQOAQAAAAAOjQOAQAAAIAOjUMAAAAAoEPjEAAAAADo0DgEAAAAADo0DgEAAACADo1DAAAAAKBD4xAAAAAA6NA4BAAAAAA6NA4BAAAAgA6NQwAAAACgQ+MQAAAAAOjQOAQAAAAAOkZqHFbVmVW1v6oOVNVLh3z+4qq6sao+W1Ufraof2fpSAQAAAIBp2bRxWFVHJbksyVOTnJzkWVV18pphn0pyamvtx5O8K8mrt7pQAAAAAGB6doww5rQkB1prNydJVV2eZG+SG1cHtNauHRh/XZJnb2WRsIxO/09vGmv8jf9iQoUAAAAAS2mUS5VPSHLrwPuD/WXreV6SDx5JUQAAAADAbI1yxmENWdaGDqx6dpJTkzx+owlXVlZG2OzmtmqeSZp2jafsGn+dwRr37NmzhdVsvK1prjtt81LrvGS/HS3a/sh/PIu0P7IfzyLtz6SzTxbreCWLtT9+++NZpP2R/XgWbX/kP55F2h/Zj2eR9udIsx+lcXgwyYkD73cluW3toKp6UpILkzy+tfbdjSbcii/sysrKVP7BeyRmUuPt468yzRoPd1vzkPeqrav1T7Zgjo3NQ/bb0Tx9H7eLRTpe8h/PIh0r2Y9vkY6X/MezSMdK9uNZpGMl+/Et0vGS/3gW6VjJ/q5GuVT5+iR7qmp3VR2d5Lwk+wYHVNUjk/xukrNba1/f+jIBAAAAgGnatHHYWrsjyQVJrklyU5IrW2s3VNUrqurs/rBLktwryTur6tNVtW+d6QAAAACAOTDKpcpprV2V5Ko1y14+8PeTtrguAAAAAGCGRrlUGQAAAABYMhqHAAAAAECHxiEAAAAA0KFxCAAAAAB0aBwCAAAAAB0ahwAAAABAh8YhAAAAANChcQgAAAAAdGgcAgAAAAAdO2ZdABv7uTN/Z6zxV79nQoVwxPae+/rxVjj96MkUAgAAADACZxwCAAAAAB0ahwAAAABAh0uVp+zcx71mvBXu6XLV7eqcs/7rBp9e3V107N0nVgsAAADAVnPGIQAAAADQoXEIAAAAAHRoHAIAAAAAHRqHAAAAAECHxiEAAAAA0OGpykfovIf9xngr3G/nZArhiJ33Ty8ab4UT7jeROgAAAAC2A2ccAgAAAAAdGocAAAAAQMdML1U+d/dLxhp/xRdeM6FK/t64NdU97zGhShbfuSf927HGX3HLb0+oEgAAAADWGqlxWFVnJvkvSY5K8sbW2m+t+fyYJG9N8qgk30pybmvtlq0tlWX3zAdcMNb4K7/62glVAgAAALD4Nr1UuaqOSnJZkqcmOTnJs6rq5DXDnpfk2621H01yaZJXbXWhAAAAAMD0VGtt4wFVP5HkotbaU/rvX5YkrbWLB8Zc0x/z51W1I8lXk/yDNjD5oUOHNt4Q287OnTtrK+aR/fyR/XKT//KS/fLaquwT+c8jv/3lJfvlJv/lJfvldTjZj/JwlBOS3Drw/mB/2dAxrbU7khxKcr9xiwEAAAAAtodRGofDupFru8qjjAEAAAAA5sQoD0c5mOTEgfe7kty2zpiD/UuVdyb5m8EBW3kJDPNF9stL9stN/stL9stN/stL9stL9stN/stL9sthlDMOr0+yp6p2V9XRSc5Lsm/NmH1Jzu//fU6SP2qb3TwRAAAAANi2Nm0c9u9ZeEGSa5LclOTK1toNVfWKqjq7P+z3k9yvqg4keXGSl06q4GGq6iVV1arquGludxRVdUlV/a+q+mxVvaeq7j3rmpKkqs6sqv1VdaCqpprXqKrq56rqhqr6QVWduuazl/Vr319VT5lVjcNU1UVV9eWq+nT/ddasa1prEvlvNmdVHVNVV/Q//3hVnbQV252kEfbpuVX1jYGsf2kWdY6jqt5UVV+vqs+v83lV1e/09/mzVXXKiPPKf5vnL/vRLVr2yWTyl/3yZt9fT/7bPH/Zj27Rsk/kP45Fy1/2o1u07JMJ5d9am+tXepdIX5Pki0mOm3U9Q+o7I8mO/t+vSvKqbVDTUUn+OskDkxyd5DNJTp51XUPqfGiSf5LkY0lOHVh+cr/mY5Ls7u/LUbOud6C+i5K8ZNZ1TDP/UeZM8itJXt//+7wkV8z6WGzBPj03yWtnXeuY+/W4JKck+fw6n5+V5IPp3bv2MUk+Lv/FyF/2y5v9JPKX/ezrnVX28p+f/GW/vNnLf7nzl/3yZj+p/Ee5VHm7uzTJr2WbPoyltfah1jtrM0muS+8ekbN2WpIDrbWbW2vfS3J5kr0zrqmjtXZTa23/kI/2Jrm8tfbd1toXkhxIb58YzSTyH2XOvUne0v/7XUmeWFXb+Z4Yc/E7GVdr7X9kzT1o19ib5K2t57ok966q4zeZVv5zQPYjW7jsk4nkL/s54bc/soXLX/YjW7jsE/mPYeHyl/3IFi77ZDL5z3XjsHqXSn+5tfaZWdcyol9Mr7M7ayckuXXg/cH+snkxD/Vf0D/t901VdZ9ZF7PGJI7fKHPeOabfTD+U5H5HuN1JGvU4PaOf9buq6sQhn8+bw/l+yH8x8pd9zzJmn4yfv+yXN/tR15H/9if7nmXMPpH/qmXMX/Y9y5h9chj5b/vGYVV9pKo+P+S1N8mFSV6+zWtcHXNhkjuS/OHsKr3TsK7/TM7YHOXYDVttyLKp1r9J3a9L8qAkj0jylSS/Pc3aRjCJ4zfKnDPPbUyj1Pv+JCe11n48yUfy9/+HbZ4dTk7yX4z8Zd+zjNkn4+ck++XNftR15L/9yb5nGbNP5L9qGfOXfc8yZp8cRk47JlTIlmmtPWnY8qr6sfTub/eZ/tmvu5J8sqpOa619dYolrlvjqqo6P8nPJnli619UPmMH07s35KpdSW6bRSGbHbt1zLz+Ueuuqjck+cCEyxnXJI7fKHOujjlYVTuS7MzGp1DP2qb71Fr71sDbN6R3H9N5dzjfD/kvRv6y71nG7JPx85f98mY/6jry3/5k37OM2SfyX7WM+cu+ZxmzTw4j/21/xuF6Wmufa63dv7V2UmvtpPR2/pRpNw03U1VnJvn3Sc5urf2/WdfTd32SPVW1u6qOTu/GpftmXNM49iU5r//Upt1J9iT5xIxrutOa+wM8PcnQpxnN0CTyH2XOfUnO7/99TpI/2iaN9PVsuk9rsj47vSfPz7t9SZ7Tf9rWY5Icaq19ZZN15L8Y+cu+ZxmzT8bPX/bLm30i/2Qx8pd9zzJmn8h/1TLmL/ueZcw+OZz82zZ46stWvJLcku35VOUD6V0//un+6/Wzrqlf11lJ/iq9pwhdOOt61qnx6ek1hL+b5GtJrhn47MJ+7fuTPHXWta6p+21JPpfks/0f5fGzrmka+Q+bM8kr0muaJ8kPJXln/zfxiSQPnPVx2IJ9ujjJDek9gevaJA+Zdc0j7NN/S+8S+u/3f1/PS/LCJC/sf15JLuvv8+cy8ERz+c93/rJf3uwnlb/slzd7+c9H/rJf3uzlv9z5y355s59U/tVfEQAAAADgTnN7qTIAAAAAMDkahwAAAABAh8YhAAAAANChcQgAAAAAdGgcAgAAAAAdGocAAAAAQIfGIQAAAADQoXEIAAAAAHT8f2GDv4WFKVCDAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1440x144 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect :()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real:  1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x144 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect :()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real:  1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x144 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incorrect :()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Summary\n",
      "Total images:  64\n",
      "Predicted for:  5\n",
      "Accuracy when predicted:  0.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(64, 0, 5)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_batch(images[:100], labels[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Simple NeuralNet.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}