BinaryAutoencoder_AWGN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {}
   },
   "source": [
    "#  Learn Modulation and Bit-Wise Demodulation in the AWGN Channel with Deep Neural Networks by Autoencoders and End-to-end Training\n",
    "\n",
    "This code is provided as supplementary material of the article \"2023 Roadmap on Optical Communications\".<br>\n",
    "\n",
    "This code illustrates\n",
    "* End-to-end-learning of modulation scheme and demodulator in an AWGN channel with binary autoencoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are using the following device for learning: cuda\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets import interactive\n",
    "import ipywidgets as widgets\n",
    "\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(\"We are using the following device for learning:\",device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper function to compute the Bit Error Rate (BER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "# helper function to compute the bit error rate\n",
    "def BER(predictions, labels):\n",
    "    return np.mean(1-np.isclose((predictions > 0.5).astype(float), labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we consider the simple AWGN channel. We modulate using a constellation with $M = 2^m$ different symbol. To symbol $i$, we assign the binary representation of $i$ as bit pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "# number of bits assigned to symbol\n",
    "m = 5\n",
    "\n",
    "# number of symbols\n",
    "M = 2**m\n",
    "\n",
    "\n",
    "EbN0 = 10\n",
    "\n",
    "# noise standard deviation\n",
    "sigma_n = np.sqrt((1/2/np.log2(M)) * 10**(-EbN0/10))\n",
    "\n",
    "# noise deviation of residual phase noise\n",
    "sigma_r = 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we define the parameters of the neural network and training, generate the validation set and a helping set to show the decision regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "# Bit representation of symbols\n",
    "binaries = torch.from_numpy(np.reshape(np.unpackbits(np.uint8(np.arange(0,2**m))), (-1,8))).float().to(device)\n",
    "binaries = binaries[:,(8-m):]\n",
    "\n",
    "# validation set. Training examples are generated on the fly\n",
    "N_valid = 100000\n",
    "\n",
    "# number of neurons in hidden layers at receiver\n",
    "hidden_neurons_RX_1 = 50\n",
    "hidden_neurons_RX_2 = 128\n",
    "hidden_neurons_RX = [hidden_neurons_RX_1, hidden_neurons_RX_2]\n",
    "\n",
    "# Generate Validation Data\n",
    "y_valid = np.random.randint(M,size=N_valid)\n",
    "y_valid_onehot = np.eye(M)[y_valid]\n",
    "y_valid_binary = binaries[y_valid,:].detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the architecture of the autoencoder, i.e. the neural network\n",
    "\n",
    "This is the main neural network/Autoencoder with transmitter, channel and receiver. Transmitter and receiver each with ELU activation function. Note that the final layer does *not* use a `softmax` function, as this function is already included in the `CrossEntropyLoss`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "class Autoencoder(nn.Module):\n",
    "    def __init__(self, hidden_neurons_RX):\n",
    "        super(Autoencoder, self).__init__()\n",
    "        \n",
    "        # Define Transmitter Layer: Linear function, M input neurons (symbols), 2 output neurons (real and imaginary part)        \n",
    "        self.fcT = nn.Linear(M, 2) \n",
    "        \n",
    "        # Define Receiver Layer: Linear function, 2 input neurons (real and imaginary part), m output neurons (bits)\n",
    "        self.fcR1 = nn.Linear(2,hidden_neurons_RX[0]) \n",
    "        self.fcR2 = nn.Linear(hidden_neurons_RX[0], hidden_neurons_RX[1]) \n",
    "        self.fcR3 = nn.Linear(hidden_neurons_RX[1], m) \n",
    "\n",
    "        # Non-linearity (used in transmitter and receiver)\n",
    "        self.activation_function = nn.ELU()      \n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # compute output\n",
    "        encoded = self.network_transmitter(x)\n",
    "        \n",
    "        # compute normalization factor and normalize channel output\n",
    "        norm_factor = torch.sqrt(torch.mean(torch.mul(encoded,encoded)) * 2 )                            \n",
    "        modulated = encoded / norm_factor    \n",
    "        received = self.channel_model(modulated)\n",
    "        \n",
    "        bitprob = self.network_receiver(received)\n",
    "        return bitprob\n",
    "        \n",
    "    def network_transmitter(self,batch_labels):\n",
    "        return self.fcT(batch_labels)\n",
    "    \n",
    "    def network_receiver(self,inp):\n",
    "        out = self.activation_function(self.fcR1(inp))\n",
    "        out = self.activation_function(self.fcR2(out))\n",
    "        logits = self.sigmoid(self.fcR3(out))        \n",
    "        return logits\n",
    "    \n",
    "    def channel_model(self,modulated):\n",
    "        # first add noise, nothing else\n",
    "        temp = torch.add(modulated, sigma_n*torch.randn(len(modulated),2).to(device))\n",
    "        \n",
    "        # add residual phase noise\n",
    "        phase_noise = sigma_r * torch.randn(len(modulated)).to(device)\n",
    "                \n",
    "        received = torch.stack((temp[:,0] * torch.cos(phase_noise) - temp[:,1] * torch.sin(phase_noise), temp[:,0] * torch.sin(phase_noise) + temp[:,1] * torch.cos(phase_noise)), dim = 1)\n",
    "        return received"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the NN and evaluate it at the end of each epoch\n",
    "\n",
    "Here the idea is to vary the batch size during training. In the first iterations, we start with a small batch size to rapidly get to a working solution. The closer we come towards the end of the training we increase the batch size. If keeping the batch size small, it may happen that there are no misclassifications in a small batch and there is no incentive of the training to improve. A larger batch size will most likely contain errors in the batch and hence there will be incentive to keep on training and improving. \n",
    "\n",
    "Here, the data is generated on the fly inside the graph, by using PyTorch random number generation. As PyTorch does not natively support complex numbers (at least in early versions), we decided to replace the complex number operations in the channel by a simple rotation matrix and treating real and imaginary parts separately.\n",
    "\n",
    "We use the ELU activation function inside the neural network and employ the Adam optimization algorithm.\n",
    "\n",
    "Now, carry out the training as such. First initialize the variables and then loop through the training. Here, the epochs are not defined in the classical way, as we do not have a training set per se. We generate new data on the fly and never reuse data. We change the batch size in each epoch.<br>\n",
    "\n",
    "To get the constellation symbols and the received data, we apply the model after each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Training\n",
      "Validation BER after epoch 0: 0.497104 (loss 0.69889629)\n",
      "Validation BER after epoch 1: 0.424828 (loss 0.68722695)\n",
      "Validation BER after epoch 2: 0.383556 (loss 0.66317296)\n",
      "Validation BER after epoch 3: 0.351420 (loss 0.60582072)\n",
      "Validation BER after epoch 4: 0.310486 (loss 0.52797395)\n",
      "Validation BER after epoch 5: 0.270914 (loss 0.44342795)\n",
      "Validation BER after epoch 6: 0.236058 (loss 0.38666674)\n",
      "Validation BER after epoch 7: 0.185644 (loss 0.34281117)\n",
      "Validation BER after epoch 8: 0.147720 (loss 0.27631852)\n",
      "Validation BER after epoch 9: 0.101648 (loss 0.21044521)\n",
      "Validation BER after epoch 10: 0.069424 (loss 0.15264873)\n",
      "Validation BER after epoch 11: 0.051958 (loss 0.13287632)\n",
      "Validation BER after epoch 12: 0.039626 (loss 0.12206197)\n",
      "Validation BER after epoch 13: 0.034592 (loss 0.10946046)\n",
      "Validation BER after epoch 14: 0.035300 (loss 0.10157874)\n",
      "Validation BER after epoch 15: 0.031160 (loss 0.08870360)\n",
      "Validation BER after epoch 16: 0.030860 (loss 0.08623604)\n",
      "Validation BER after epoch 17: 0.029208 (loss 0.09054773)\n",
      "Validation BER after epoch 18: 0.028584 (loss 0.08413332)\n",
      "Validation BER after epoch 19: 0.027990 (loss 0.08107524)\n",
      "Validation BER after epoch 20: 0.028102 (loss 0.07699952)\n",
      "Validation BER after epoch 21: 0.027446 (loss 0.07582303)\n",
      "Validation BER after epoch 22: 0.026588 (loss 0.06967378)\n",
      "Validation BER after epoch 23: 0.026874 (loss 0.06932914)\n",
      "Validation BER after epoch 24: 0.026272 (loss 0.06955215)\n",
      "Validation BER after epoch 25: 0.025892 (loss 0.07609556)\n",
      "Validation BER after epoch 26: 0.025184 (loss 0.06987416)\n",
      "Validation BER after epoch 27: 0.024904 (loss 0.06258848)\n",
      "Validation BER after epoch 28: 0.024622 (loss 0.06425975)\n",
      "Validation BER after epoch 29: 0.024046 (loss 0.06008948)\n",
      "Validation BER after epoch 30: 0.023876 (loss 0.06262415)\n",
      "Validation BER after epoch 31: 0.023362 (loss 0.06349622)\n",
      "Validation BER after epoch 32: 0.023162 (loss 0.06018104)\n",
      "Validation BER after epoch 33: 0.022426 (loss 0.05627266)\n",
      "Validation BER after epoch 34: 0.022254 (loss 0.05854617)\n",
      "Validation BER after epoch 35: 0.022190 (loss 0.05657140)\n",
      "Validation BER after epoch 36: 0.022276 (loss 0.05567491)\n",
      "Validation BER after epoch 37: 0.021666 (loss 0.06040512)\n",
      "Validation BER after epoch 38: 0.021614 (loss 0.06642237)\n",
      "Validation BER after epoch 39: 0.021470 (loss 0.06401752)\n",
      "Validation BER after epoch 40: 0.021446 (loss 0.05678274)\n",
      "Validation BER after epoch 41: 0.021240 (loss 0.05750655)\n",
      "Validation BER after epoch 42: 0.020988 (loss 0.05710088)\n",
      "Validation BER after epoch 43: 0.020756 (loss 0.05682858)\n",
      "Validation BER after epoch 44: 0.020604 (loss 0.06071083)\n",
      "Validation BER after epoch 45: 0.021012 (loss 0.05565947)\n",
      "Validation BER after epoch 46: 0.021154 (loss 0.05195786)\n",
      "Validation BER after epoch 47: 0.020700 (loss 0.05559721)\n",
      "Validation BER after epoch 48: 0.020320 (loss 0.05314543)\n",
      "Validation BER after epoch 49: 0.020520 (loss 0.06004326)\n",
      "Validation BER after epoch 50: 0.020308 (loss 0.05383276)\n",
      "Validation BER after epoch 51: 0.019912 (loss 0.05442137)\n",
      "Validation BER after epoch 52: 0.020324 (loss 0.05482395)\n",
      "Validation BER after epoch 53: 0.020028 (loss 0.04745307)\n",
      "Validation BER after epoch 54: 0.019770 (loss 0.05566514)\n",
      "Validation BER after epoch 55: 0.020022 (loss 0.05707015)\n",
      "Validation BER after epoch 56: 0.019632 (loss 0.05605217)\n",
      "Validation BER after epoch 57: 0.019480 (loss 0.04719141)\n",
      "Validation BER after epoch 58: 0.019406 (loss 0.05484674)\n",
      "Validation BER after epoch 59: 0.019388 (loss 0.04804781)\n",
      "Validation BER after epoch 60: 0.019198 (loss 0.05135683)\n",
      "Validation BER after epoch 61: 0.019078 (loss 0.04918223)\n",
      "Validation BER after epoch 62: 0.019194 (loss 0.04667851)\n",
      "Validation BER after epoch 63: 0.019404 (loss 0.04772661)\n",
      "Validation BER after epoch 64: 0.019222 (loss 0.04421264)\n",
      "Validation BER after epoch 65: 0.018946 (loss 0.05032162)\n",
      "Validation BER after epoch 66: 0.019324 (loss 0.04700603)\n",
      "Validation BER after epoch 67: 0.019380 (loss 0.04542248)\n",
      "Validation BER after epoch 68: 0.018958 (loss 0.05182615)\n",
      "Validation BER after epoch 69: 0.018980 (loss 0.05100495)\n",
      "Validation BER after epoch 70: 0.018802 (loss 0.04986474)\n",
      "Validation BER after epoch 71: 0.018978 (loss 0.04681146)\n",
      "Validation BER after epoch 72: 0.018450 (loss 0.04935806)\n",
      "Validation BER after epoch 73: 0.019008 (loss 0.04629197)\n",
      "Validation BER after epoch 74: 0.018630 (loss 0.04787171)\n",
      "Validation BER after epoch 75: 0.018402 (loss 0.04974803)\n",
      "Validation BER after epoch 76: 0.018680 (loss 0.05042858)\n",
      "Validation BER after epoch 77: 0.018630 (loss 0.04710205)\n",
      "Validation BER after epoch 78: 0.018704 (loss 0.05309783)\n",
      "Validation BER after epoch 79: 0.018506 (loss 0.04775067)\n",
      "Validation BER after epoch 80: 0.018688 (loss 0.04697919)\n",
      "Validation BER after epoch 81: 0.018436 (loss 0.04885621)\n",
      "Validation BER after epoch 82: 0.018428 (loss 0.04790449)\n",
      "Validation BER after epoch 83: 0.018170 (loss 0.04671417)\n",
      "Validation BER after epoch 84: 0.018738 (loss 0.04948730)\n",
      "Validation BER after epoch 85: 0.018382 (loss 0.05514935)\n",
      "Validation BER after epoch 86: 0.018736 (loss 0.05090616)\n",
      "Validation BER after epoch 87: 0.018422 (loss 0.04922121)\n",
      "Validation BER after epoch 88: 0.018474 (loss 0.05155531)\n",
      "Validation BER after epoch 89: 0.018562 (loss 0.04599718)\n",
      "Validation BER after epoch 90: 0.018394 (loss 0.05233142)\n",
      "Validation BER after epoch 91: 0.017770 (loss 0.05374604)\n",
      "Validation BER after epoch 92: 0.018886 (loss 0.04854117)\n",
      "Validation BER after epoch 93: 0.018292 (loss 0.05219673)\n",
      "Validation BER after epoch 94: 0.018542 (loss 0.05014569)\n",
      "Validation BER after epoch 95: 0.018344 (loss 0.05489914)\n",
      "Validation BER after epoch 96: 0.018510 (loss 0.04901562)\n",
      "Validation BER after epoch 97: 0.018468 (loss 0.04845739)\n",
      "Validation BER after epoch 98: 0.017822 (loss 0.04484692)\n",
      "Validation BER after epoch 99: 0.018216 (loss 0.04657259)\n",
      "Validation BER after epoch 100: 0.018674 (loss 0.04996742)\n",
      "Validation BER after epoch 101: 0.018526 (loss 0.04925341)\n",
      "Validation BER after epoch 102: 0.018322 (loss 0.04687422)\n",
      "Validation BER after epoch 103: 0.018250 (loss 0.04614037)\n",
      "Validation BER after epoch 104: 0.018174 (loss 0.04678056)\n",
      "Validation BER after epoch 105: 0.018262 (loss 0.04774999)\n",
      "Validation BER after epoch 106: 0.018482 (loss 0.04836396)\n",
      "Validation BER after epoch 107: 0.018278 (loss 0.04685009)\n",
      "Validation BER after epoch 108: 0.018002 (loss 0.04925755)\n",
      "Validation BER after epoch 109: 0.018454 (loss 0.04635764)\n",
      "Validation BER after epoch 110: 0.017974 (loss 0.05183604)\n",
      "Validation BER after epoch 111: 0.017864 (loss 0.04805331)\n",
      "Validation BER after epoch 112: 0.018106 (loss 0.05135226)\n",
      "Validation BER after epoch 113: 0.018326 (loss 0.04757949)\n",
      "Validation BER after epoch 114: 0.018200 (loss 0.04507482)\n",
      "Validation BER after epoch 115: 0.018072 (loss 0.04555295)\n",
      "Validation BER after epoch 116: 0.018332 (loss 0.04459264)\n",
      "Validation BER after epoch 117: 0.018040 (loss 0.04560778)\n",
      "Validation BER after epoch 118: 0.017966 (loss 0.04652113)\n",
      "Validation BER after epoch 119: 0.018342 (loss 0.04606457)\n",
      "Validation BER after epoch 120: 0.018224 (loss 0.04683641)\n",
      "Validation BER after epoch 121: 0.017962 (loss 0.04786240)\n",
      "Validation BER after epoch 122: 0.018016 (loss 0.04666833)\n",
      "Validation BER after epoch 123: 0.018028 (loss 0.05200344)\n",
      "Validation BER after epoch 124: 0.018004 (loss 0.04880731)\n",
      "Validation BER after epoch 125: 0.017788 (loss 0.04734636)\n",
      "Validation BER after epoch 126: 0.018440 (loss 0.04972196)\n",
      "Validation BER after epoch 127: 0.018160 (loss 0.05207642)\n",
      "Validation BER after epoch 128: 0.018244 (loss 0.04820837)\n",
      "Validation BER after epoch 129: 0.017994 (loss 0.04763028)\n",
      "Validation BER after epoch 130: 0.017904 (loss 0.04953650)\n",
      "Validation BER after epoch 131: 0.018032 (loss 0.04597030)\n",
      "Validation BER after epoch 132: 0.018122 (loss 0.04738627)\n",
      "Validation BER after epoch 133: 0.018268 (loss 0.05004848)\n",
      "Validation BER after epoch 134: 0.018480 (loss 0.04644527)\n",
      "Validation BER after epoch 135: 0.018128 (loss 0.04629905)\n",
      "Validation BER after epoch 136: 0.018172 (loss 0.04673310)\n",
      "Validation BER after epoch 137: 0.018154 (loss 0.04531990)\n",
      "Validation BER after epoch 138: 0.018016 (loss 0.04783006)\n",
      "Validation BER after epoch 139: 0.018004 (loss 0.05212057)\n",
      "Validation BER after epoch 140: 0.017744 (loss 0.05015887)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation BER after epoch 141: 0.018332 (loss 0.04722489)\n",
      "Validation BER after epoch 142: 0.017806 (loss 0.05121915)\n",
      "Validation BER after epoch 143: 0.018450 (loss 0.04739399)\n",
      "Validation BER after epoch 144: 0.018016 (loss 0.04730428)\n",
      "Validation BER after epoch 145: 0.018388 (loss 0.04659101)\n",
      "Validation BER after epoch 146: 0.017958 (loss 0.04847778)\n",
      "Validation BER after epoch 147: 0.017966 (loss 0.04725357)\n",
      "Validation BER after epoch 148: 0.017922 (loss 0.04732799)\n",
      "Validation BER after epoch 149: 0.017768 (loss 0.04624471)\n",
      "Training finished\n"
     ]
    }
   ],
   "source": [
    "model = Autoencoder(hidden_neurons_RX)\n",
    "model.to(device)\n",
    "\n",
    "    \n",
    "loss_fn = nn.BCELoss()\n",
    "\n",
    "# Adam Optimizer\n",
    "optimizer = optim.Adam(model.parameters())  \n",
    "\n",
    "\n",
    "# Training parameters\n",
    "num_epochs = 150\n",
    "batches_per_epoch = np.linspace(1, 1000, num=num_epochs).astype(int)\n",
    "\n",
    "# Vary batch size during training\n",
    "batch_size_per_epoch = np.linspace(200,5000,num=num_epochs)\n",
    "learning_rate_per_epoch = np.linspace(0.001, 0.00001, num=num_epochs)\n",
    "\n",
    "validation_BERs = np.zeros(num_epochs)\n",
    "validation_received = []\n",
    "constellations = []\n",
    "\n",
    "print('Start Training')\n",
    "for epoch in range(num_epochs):\n",
    "    \n",
    "    batch_labels = torch.empty(int(batch_size_per_epoch[epoch]), device=device)\n",
    "    batch_labels_binary = torch.zeros(int(batch_size_per_epoch[epoch]), m, device=device)\n",
    "        \n",
    "    \n",
    "    for step in range(batches_per_epoch[epoch]):\n",
    "        # Generate training data: In most cases, you have a dataset and do not generate a training dataset during training loop\n",
    "        # sample new mini-batch directory on the GPU (if available)        \n",
    "        batch_labels.random_(M)\n",
    "        batch_labels_onehot = torch.zeros(int(batch_size_per_epoch[epoch]), M, device=device)\n",
    "        batch_labels_onehot[range(batch_labels_onehot.shape[0]), batch_labels.long()]=1\n",
    "\n",
    "        batch_labels_binary[range(batch_labels_onehot.shape[0]), :] = binaries[batch_labels.long(),:]\n",
    "\n",
    "        \n",
    "        # Propagate (training) data through the net\n",
    "        NN_output = model(batch_labels_onehot)\n",
    "\n",
    "        # compute loss\n",
    "        loss = loss_fn(NN_output, batch_labels_binary)\n",
    "\n",
    "        # compute gradients\n",
    "        loss.backward()\n",
    "        \n",
    "        # Adapt weights\n",
    "        optimizer.step()\n",
    "        \n",
    "        # reset gradients\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "    optimizer.param_groups[0]['lr'] = learning_rate_per_epoch[epoch]\n",
    "    \n",
    "    # compute validation BER\n",
    "    out_valid = model(torch.Tensor(y_valid_onehot).to(device))\n",
    "    validation_BERs[epoch] = BER(out_valid.detach().cpu().numpy(), y_valid_binary)\n",
    "    print('Validation BER after epoch %d: %f (loss %1.8f)' % (epoch, validation_BERs[epoch], loss.detach().cpu().numpy()))                \n",
    "\n",
    "     # calculate and store received validation data\n",
    "    encoded = model.network_transmitter(torch.Tensor(y_valid_onehot).to(device))\n",
    "    norm_factor = torch.sqrt(torch.mean(torch.mul(encoded,encoded)) * 2 )                          \n",
    "    modulated = encoded / norm_factor    \n",
    "    received = model.channel_model(modulated)\n",
    "    validation_received.append(received.detach().cpu().numpy())\n",
    "    \n",
    "    # calculate and store constellation\n",
    "    encoded = model.network_transmitter(torch.eye(M).to(device))\n",
    "    norm_factor = torch.sqrt(torch.mean(torch.mul(encoded,encoded)) * 2 )                            \n",
    "    modulated = encoded / norm_factor \n",
    "    constellations.append(modulated.detach().cpu().numpy())\n",
    "\n",
    "    \n",
    "print('Training finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plt decision region and scatter plot of the validation set. Note that the validation set is **only** used for computing SERs and plotting, there is no feedback towards the training!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cmap = matplotlib.cm.tab20\n",
    "base = plt.cm.get_cmap(cmap)\n",
    "color_list = base.colors\n",
    "new_color_list = [[t/2 + 0.5 for t in color_list[k]] for k in range(len(color_list))]\n",
    "\n",
    "# find minimum SER from validation set\n",
    "min_BER_iter = np.argmin(validation_BERs)\n",
    "\n",
    "plt.figure(figsize=(10,8))\n",
    "font = {'size'   : 14}\n",
    "plt.rc('font', **font)\n",
    "plt.rc('text', usetex=matplotlib.checkdep_usetex(True))\n",
    "\n",
    "bin_labels = [np.binary_repr(j).zfill(m) for j in range(2**m)]\n",
    "\n",
    "   \n",
    "plt.scatter(constellations[min_BER_iter][:,0], constellations[min_BER_iter][:,1], c=range(M), cmap='tab20',s=50)\n",
    "for i, txt in enumerate(bin_labels):\n",
    "    plt.annotate(txt, xy=(constellations[min_BER_iter][i,0], constellations[min_BER_iter][i,1]), xycoords='data', \\\n",
    "                      xytext=(0, 3), textcoords='offset points', \\\n",
    "                      ha='center', va='bottom')\n",
    "    \n",
    "plt.axis('scaled')\n",
    "plt.xlabel(r'$\\Re\\{y\\}$',fontsize=24)\n",
    "plt.ylabel(r'$\\Im\\{y\\}$',fontsize=24)\n",
    "plt.xlim((-1.7, +1.7))\n",
    "plt.ylim((-1.7, +1.7))\n",
    "plt.grid(which='both')\n",
    "plt.title('Constellation with Bit Mapping',fontsize=18)\n",
    "plt.savefig('learning_AWGN_BitAE_EbN0%1.1f_M%d.pdf' % (EbN0,M),bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Received')"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1368x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "plt.figure(figsize=(19,6))\n",
    "font = {'size'   : 14}\n",
    "plt.rc('font', **font)\n",
    "plt.rc('text', usetex=matplotlib.checkdep_usetex(True))\n",
    "    \n",
    "plt.subplot(121)\n",
    "plt.scatter(constellations[min_BER_iter][:,0], constellations[min_BER_iter][:,1], c=range(M), cmap='tab20',s=50)\n",
    "plt.axis('scaled')\n",
    "plt.xlabel(r'$\\Re\\{y\\}$',fontsize=14)\n",
    "plt.ylabel(r'$\\Im\\{y\\}$',fontsize=14)\n",
    "plt.xlim((-1.7, +1.7))\n",
    "plt.ylim((-1.7, +1.7))\n",
    "plt.grid(which='both')\n",
    "plt.title('Constellation',fontsize=16)\n",
    "\n",
    "plt.subplot(122)\n",
    "#plt.contourf(mgx,mgy,decision_region_evolution[-1].reshape(mgy.shape).T,cmap='coolwarm',vmin=0.3,vmax=0.7)\n",
    "plt.scatter(validation_received[min_BER_iter][:,0], validation_received[min_BER_iter][:,1], c=y_valid, cmap='tab20',s=4)\n",
    "plt.axis('scaled')\n",
    "plt.xlabel(r'$\\Re\\{y\\}$',fontsize=14)\n",
    "plt.ylabel(r'$\\Im\\{y\\}$',fontsize=14)\n",
    "plt.xlim((-1.7, +1.7))\n",
    "plt.ylim((-1.7, +1.7))\n",
    "plt.title('Received',fontsize=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate animation and save as a gif. (Evaluate results III)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function () {\n",
       "    if (typeof WebSocket !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert(\n",
       "            'Your browser does not have WebSocket support. ' +\n",
       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "                'Firefox 4 and 5 are also supported but you ' +\n",
       "                'have to enable WebSockets in about:config.'\n",
       "        );\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById('mpl-warnings');\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent =\n",
       "                'This browser does not support binary websocket messages. ' +\n",
       "                'Performance may be slow.';\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen = function () {\n",
       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
       "        fig.send_message('send_image_mode', {});\n",
       "        if (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
       "        }\n",
       "        fig.send_message('refresh', {});\n",
       "    };\n",
       "\n",
       "    this.imageObj.onload = function () {\n",
       "        if (fig.image_mode === 'full') {\n",
       "            // Full images could contain transparency (where diff images\n",
       "            // almost always do), so we need to clear the canvas so that\n",
       "            // there is no ghosting.\n",
       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "        }\n",
       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "    };\n",
       "\n",
       "    this.imageObj.onunload = function () {\n",
       "        fig.ws.close();\n",
       "    };\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_header = function () {\n",
       "    var titlebar = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus() {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_message = function (type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function () {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch (cursor) {\n",
       "        case 0:\n",
       "            cursor = 'pointer';\n",
       "            break;\n",
       "        case 1:\n",
       "            cursor = 'default';\n",
       "            break;\n",
       "        case 2:\n",
       "            cursor = 'crosshair';\n",
       "            break;\n",
       "        case 3:\n",
       "            cursor = 'move';\n",
       "            break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message('ack', {});\n",
       "};\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = 'image/png';\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",
       "                );\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data']);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"576\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function () {\n",
       "    if (typeof WebSocket !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert(\n",
       "            'Your browser does not have WebSocket support. ' +\n",
       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "                'Firefox 4 and 5 are also supported but you ' +\n",
       "                'have to enable WebSockets in about:config.'\n",
       "        );\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById('mpl-warnings');\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent =\n",
       "                'This browser does not support binary websocket messages. ' +\n",
       "                'Performance may be slow.';\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen = function () {\n",
       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
       "        fig.send_message('send_image_mode', {});\n",
       "        if (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
       "        }\n",
       "        fig.send_message('refresh', {});\n",
       "    };\n",
       "\n",
       "    this.imageObj.onload = function () {\n",
       "        if (fig.image_mode === 'full') {\n",
       "            // Full images could contain transparency (where diff images\n",
       "            // almost always do), so we need to clear the canvas so that\n",
       "            // there is no ghosting.\n",
       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "        }\n",
       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "    };\n",
       "\n",
       "    this.imageObj.onunload = function () {\n",
       "        fig.ws.close();\n",
       "    };\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_header = function () {\n",
       "    var titlebar = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus() {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_message = function (type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function () {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch (cursor) {\n",
       "        case 0:\n",
       "            cursor = 'pointer';\n",
       "            break;\n",
       "        case 1:\n",
       "            cursor = 'default';\n",
       "            break;\n",
       "        case 2:\n",
       "            cursor = 'crosshair';\n",
       "            break;\n",
       "        case 3:\n",
       "            cursor = 'move';\n",
       "            break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message('ack', {});\n",
       "};\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = 'image/png';\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",
       "                );\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data']);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"576\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "%matplotlib notebook\n",
    "# Generate animation\n",
    "from matplotlib import animation, rc\n",
    "from matplotlib.animation import PillowWriter # Disable if you don't want to save any GIFs.\n",
    "\n",
    "font = {'size'   : 18}\n",
    "plt.rc('font', **font)\n",
    "\n",
    "fig = plt.figure(figsize=(8,6))\n",
    "ax1 = fig.add_subplot(1,1,1)\n",
    "\n",
    "ax1.axis('scaled')\n",
    "\n",
    "written = False\n",
    "def animate(i):\n",
    "    ax1.clear()\n",
    "    ax1.scatter(constellations[i][:,0], constellations[i][:,1], c=range(M), cmap='tab20',s=50)\n",
    "\n",
    "    for j, txt in enumerate(bin_labels):\n",
    "        ax1.annotate(txt, xy=(constellations[i][j,0], constellations[i][j,1]), xycoords='data', \\\n",
    "                      xytext=(0, 3), textcoords='offset points', \\\n",
    "                      ha='center', va='bottom', fontsize=12)\n",
    "    \n",
    "    \n",
    "    ax1.set_xlim(( -1.7, +1.7))\n",
    "    ax1.set_ylim(( -1.7, +1.7))\n",
    "    ax1.set_title('Constellation', fontsize=18)\n",
    "    \n",
    "    ax1.set_xlabel(r'$\\Re\\{y\\}$',fontsize=16)\n",
    "    ax1.set_ylabel(r'$\\Im\\{y\\}$',fontsize=16)\n",
    "\n",
    "    \n",
    "anim = animation.FuncAnimation(fig, animate, frames=min_BER_iter+1, interval=200, blit=False)\n",
    "fig.show()\n",
    "anim.save('learning_AWGN_BitAE_EbN0%1.1f_M%d.gif' % (EbN0,M), writer=PillowWriter(fps=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.15"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}