IA_A_Gentle_Introduction_to_Information_Entropy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "IA_A Gentle Introduction to Information Entropy.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyN5SzfDiWGYY6nJQ0cR5DTf",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MedicalImageAnalysisTutorials/MutualInformationTutorial/blob/master/IA_A_Gentle_Introduction_to_Information_Entropy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jec-On2iQqMa"
      },
      "source": [
        "# A Gentle Introduction to Information Entropy\n",
        "\n",
        "source: Jason Brownlee https://machinelearningmastery.com/what-is-information-entropy/\n",
        "\n",
        "I just convert the article toa colab notebook to be easy to practice."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UcJtU5beQ75b"
      },
      "source": [
        "\n",
        "Information theory is a subfield of mathematics concerned with transmitting data across a noisy channel.\n",
        "\n",
        "A cornerstone of information theory is the idea of quantifying how much information there is in a message. More generally, this can be used to quantify the information in an event and a random variable, called entropy, and is calculated using probability.\n",
        "\n",
        "Calculating information and entropy is a useful tool in machine learning and is used as the basis for techniques such as feature selection, building decision trees, and, more generally, fitting classification models. As such, a machine learning practitioner requires a strong understanding and intuition for information and entropy.\n",
        "\n",
        "In this post, you will discover a gentle introduction to information entropy.\n",
        "\n",
        "After reading this post, you will know:\n",
        "\n",
        " * Information theory is concerned with data compression and transmission and builds upon probability and supports machine learning.\n",
        " *  Information provides a way to quantify the amount of surprise for an event measured in bits.\n",
        " * Entropy provides a measure of the average amount of information needed to represent an event drawn from a probability distribution for a random variable.\n",
        "Kick-start your project with my new book Probability for Machine Learning, including step-by-step tutorials and the Python source code files for all examples.\n",
        "\n",
        "Let’s get started.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_nDawFmROoT"
      },
      "source": [
        "## What Is Information Theory?\n",
        "\n",
        "[Information theory](https://en.wikipedia.org/wiki/Information_theory) is a field of study concerned with quantifying information for communication.\n",
        "\n",
        "It is a subfield of mathematics and is concerned with topics like data compression and the limits of signal processing. The field was proposed and developed by Claude Shannon while working at the US telephone company Bell Labs.\n",
        "\n",
        "```\n",
        "Information theory is concerned with representing data in a compact fashion \n",
        "(a task known as data compression or source coding), \n",
        "as well as with transmitting and storing it in a way that is robust to errors\n",
        "(a task known as error correction or channel coding).\n",
        "\n",
        "— Page 56, Machine Learning: A Probabilistic Perspective, 2012.\n",
        "```\n",
        "\n",
        "A foundational concept from information is the quantification of the amount of information in things like events, random variables, and distributions.\n",
        "\n",
        "Quantifying the amount of information requires the use of probabilities, hence the relationship of information theory to probability.\n",
        "\n",
        "Measurements of information are widely used in artificial intelligence and machine learning, such as in the construction of decision trees and the optimization of classifier models.\n",
        "\n",
        "As such, there is an important relationship between information theory and machine learning and a practitioner must be familiar with some of the basic concepts from the field.\n",
        "\n",
        "```\n",
        "Why unify information theory and machine learning? Because they are two sides of the same coin.\n",
        "Information theory and machine learning still belong together. \n",
        "Brains are the ultimate compression and communication systems.\n",
        " And the state-of-the-art algorithms for both data compression and error-correcting codes use the same tools as machine learning.\n",
        "\n",
        "— Page v, Information Theory, Inference, and Learning Algorithms, 2003.\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NEZr6VXVSTOH"
      },
      "source": [
        "## Calculate the Information for an Event\n",
        "\n",
        "Quantifying information is the foundation of the field of information theory.\n",
        "\n",
        "The intuition behind quantifying information is the idea of measuring how much surprise there is in an event. Those events that are rare (low probability) are more surprising and therefore have more information than those events that are common (high probability).\n",
        "\n",
        "  * Low Probability Event: High Information (surprising).\n",
        "  * High Probability Event: Low Information (unsurprising).\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "The basic intuition behind information theory is that learning that\n",
        " an unlikely event has occurred is more informative than learning that\n",
        "  a likely event has occurred.\n",
        "\n",
        "— Page 73, Deep Learning, 2016. \n",
        "```\n",
        "\n",
        "\n",
        "Rare events are more uncertain or more surprising and require more information to represent them than common events.\n",
        "\n",
        "We can calculate the amount of information there is in an event using the probability of the event. This is called “Shannon information,” “self-information,” or simply the “information,” and can be calculated for a discrete event x as follows:\n",
        "\n",
        "$$\n",
        "information(x) = -log_2( p(x) )\n",
        "$$\n",
        "\n",
        "Where $log()$ is the base-2 logarithm and $p(x)$ is the probability of the event $x$.\n",
        "\n",
        "The choice of the base-2 logarithm means that the units of the information measure is in bits (binary digits). This can be directly interpreted in the information processing sense as the number of bits required to represent the event.\n",
        "\n",
        "The calculation of information is often written as h(); for example:\n",
        "$$\n",
        "h(x) = -log_2( p(x) )\n",
        "$$\n",
        "\n",
        "The negative sign ensures that the result is always positive or zero.\n",
        "\n",
        "Information will be zero when the probability of an event is 1.0 or a certainty, e.g. there is no surprise.\n",
        "\n",
        "Let’s make this concrete with some examples.\n",
        "\n",
        "Consider a flip of a single fair coin. The probability of heads (and tails) is 0.5. We can calculate the information for flipping a head in Python using the $log2()$ function.\n",
        "\n",
        "Running the example prints the probability of the event as 50% and the information content for the event as 1 bit.\n",
        "\n",
        "f the same coin was flipped $n$ times, then the information for this sequence of flips would be $n$ bits.\n",
        "\n",
        "If the coin was not fair and the probability of a head was instead 10% (0.1), then the event would be more rare and would require more than 3 bits of information.\n",
        "\n",
        "We can also explore the information in a single roll of a fair six-sided dice, e.g. the information in rolling a 6.\n",
        "\n",
        "We know the probability of rolling any number is 1/6, which is a smaller number than 1/2 for a coin flip, therefore we would expect more surprise or a larger amount of information."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FFRujtC9QlsM",
        "outputId": "3404dc7e-9973-4eb6-961d-a64e2ea91cce"
      },
      "source": [
        "# calculate the information for a coin flip\n",
        "from math import log2\n",
        "\n",
        "def getPH(p):\n",
        "    # calculate information for event\n",
        "    # using the probability of the event p \n",
        "    h = -log2(p)\n",
        "    return h\n",
        "\n",
        "\n",
        "# print the result os some examples:\n",
        "print('fair coin flip   :  p(x)=%.3f, information: %.3f bits' % (0.5, getPH(0.5)))\n",
        "print('unfair coin flip :  p(x)=%.3f, information: %.3f bits' % (0.1, getPH(0.1)))\n",
        "print('unfair coin flip :  p(x)=%.3f, information: %.3f bits' % (0.9, getPH(0.9)))\n",
        "print('unfair coin flip :  p(x)=%.3f, information: %.3f bits' % (1.0, getPH(1.0)))\n",
        "print('fair dice roll   :  p(x)=%.3f, information: %.3f bits' % (1.0/6.0, getPH(1.0/6.0)))\n",
        "\n",
        "\n",
        "print(\"more probability means we know the outcome so the computed information is more useless\")"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "fair coin flip   :  p(x)=0.500, information: 1.000 bits\n",
            "unfair coin flip :  p(x)=0.100, information: 3.322 bits\n",
            "unfair coin flip :  p(x)=0.900, information: 0.152 bits\n",
            "unfair coin flip :  p(x)=1.000, information: -0.000 bits\n",
            "fair dice roll   :  p(x)=0.167, information: 2.585 bits\n",
            "more probability means we know the outcome so the computed information is more useless\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cB6qHSzTQxgF"
      },
      "source": [
        "## Probablility vs Information \n",
        "\n",
        "Other logarithms can be used instead of the base-2. For example, it is also common to use the natural logarithm that uses base-e (Euler’s number) in calculating the information, in which case the units are referred to as “nats.”\n",
        "\n",
        "We can further develop the intuition that low probability events have more information.\n",
        "\n",
        "To make this clear, we can calculate the information for probabilities between 0 and 1 and plot the corresponding information for each. We can then create a plot of probability vs information. We would expect the plot to curve downward from low probabilities with high information to high probabilities with low information.\n",
        "\n",
        "The complete example is listed below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "EMKK-MKnWmhP",
        "outputId": "5684e0ce-2f3e-43f7-cb46-35edf3bf2bde"
      },
      "source": [
        "# compare probability vs information entropy\n",
        "from math import log2\n",
        "from matplotlib import pyplot\n",
        "# list of probabilities\n",
        "probs = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\n",
        "# calculate information\n",
        "info = [-log2(p) for p in probs]\n",
        "# plot probability vs information\n",
        "pyplot.plot(probs, info, marker='.')\n",
        "pyplot.title('Probability vs Information')\n",
        "pyplot.xlabel('Probability')\n",
        "pyplot.ylabel('Information')\n",
        "pyplot.show()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5hU5fn/8fc92+h1lyK9FxFFulgQ1GCPsRs1GkuIJTGa5GeqxpiYfP3Gb2JJLLFXYmISgxoTBKVEkKIgsHRYOiy9rLtsuX9/zCEZycLOsjtzZnc+r+uaiznnPOece88uc89TznPM3RERkfQVCTsAEREJlxKBiEiaUyIQEUlzSgQiImlOiUBEJM0pEYiIpDklAkkKM3Mz63mU+64xszMOs+0UM1taWVkz+76Z/f7oIg6fmfUxs0/MbK+ZfSPseA5lZo+b2Y/CjkNqLjPsACR1mdkaoC1QDuwH3gFuc/d9YcYVy92nAX0Os+3nB9+bWVdgNZDl7mVJCa4SZuZAL3dfEUfx7wJT3P2EBIdVJTO7DrjR3U8+uM7dx4cXkdQm1QikKue7exPgRGAI8MNDC5iZvlAkRhdg0dHsqN+JVIcSgcTF3TcQrREMgH839dxqZsuB5cG6m8xshZntMLM3zeyYQw5zjpmtMrNtZvagmUWC/XqY2WQz2x5se9nMWhyy71AzW2xmO83sWTNrEOw72szWVxazmd1rZi8Fi1ODf3eZ2T4zOy2I87iY8m3MrMjM8g45To6Z7TKzATHr8szss2CfXDObGJTZYWbTDv5sRxLE9wczeyFo/llkZkOCbZOB04FHg3h7m1nzoGyhmRWY2Q9jruF1ZjbDzP7PzLYD95rZc2b2WzN7JzjGDDNrZ2a/Dq7jEjMbFBPP3Wa2MohlsZldFKzvBzwOjAyOsytY/5yZ3R+z/2F//8Hfy3gzWx5cp8fMzKq6RpIcSgQSFzPrBJwDfByz+ovAcKC/mY0BHgAuA9oDBcBrhxzmIqK1ihOBC4GvHjx8sO8xQD+gE3DvIft+GfgC0APoTSU1kyqcGvzbwt2buPsHQXxXx5S5EnjP3Qtjd3T3EuCNYPtBlwEfuPtW4C5gPZBHtCnt+0C8c7dcEMTRAngTeDQ45xhgGtGmuCbuvgx4BGgOdAdOA64Fro851nBgVRDDz2Li/CGQC5QAHwLzguU/Ag/F7L8SOCU4x0+Al8ysvbvnA+OBD4NYDk3SxPn7Pw8YCgwMyn0hzmskCaZEIFX5S/ANcDrwAfDzmG0PuPsOd/+M6Af1M+4+L/jg/B7Rb5BdY8r/Mii/Fvg1wQeru69w93+6e0nwIfwQ0Q+6WI+6+zp330H0Q+5Kau554MqYb6bXAC8epuwrwBUxy1cF6wBKiX74dXH3Unef5vFP4jXd3d929/Lg3MdXVsjMMoLzf8/d97r7GuBXQcwHbXT3R9y9LPidAPzZ3ee6ezHwZ6DY3V8IzjcB+HeNwN1fd/eN7l7h7hOI1vSGxflzxPP7/4W77wp+/1OA0Ps+JEqJQKryRXdv4e5d3P2WmA8YgHUx748h+i0QgKBDeTvQ4TDlC4J9MLO2ZvaamW0wsz3AS0S/sVLVvjXh7rOAImC0mfUFehL9Vl6ZKUAjMxsefLidQPSDFeBBYAXwj6Dp6+5qhLE55n0R0OAw7fu5QBYx1zh4f7jre9CWmPefVbLc5OCCmV1r0VFKu4LkP4D//j0cTjy//0N/1iZISlAikJqI/da7kWjnJgBm1hhoDWyIKdMp5n3nYB+I1jIcOM7dmxFtrjm0/fhw+x5NrLGeD853DfDH4Jvzf+8c/Qb9B6I1kSuBie6+N9i2193vcvfuRJt67jSzsdWMryrbiNY8usSs68znr+9RTyVsZl2Ap4DbgNZB889C/vN7qOrY8fz+JUUpEUhteRW43sxOMLMcoh/us4ImjIO+Y2Ytg/6GbxJtmgBoCuwDdptZB+A7lRz/VjPraGatgB/E7BuvQqCCaPt6rJeI9l1cDbxQxTFeAS4n2gxysFkIMzvPzHoGTUy7iQ63rahmfEcUk4h+ZmZNgw/uO4P4a0Njoh/2hQBmdj3BwIDAFqCjmWUfZv94fv+SopQIpFa4+yTgR8CfgE1EO3WvOKTYX4G5wCfAW8DTwfqfEO1A3h2sf6OSU7wC/INoZ+hK4P5KyhwpviKifQszgqaPEcH6dUQ7T51o5+yRjjGL6P0UxxAdQXVQL2AS0WT2IfBbd59SnfjidHtw/lVE+2xeAZ6pjQO7+2KifQ4fEv3QPw6YEVNkMtGhrJvNbFsl+8fz+5cUZXowjaQ7M3uGaEdrdUciidQLuulE0lrQ8fslYkbPiKQbNQ1J2jKznxLtEH3Q3VeHHY9IWNQ0JCKS5lQjEBFJc3WujyA3N9e7du0adhgiInXK3Llzt7l7XmXb6lwi6Nq1K3PmzAk7DBGROsXMCg63TU1DIiJpTolARCTNKRGIiKQ5JQIRkTSnRCAikuaUCERE0lzaJIK5BTt5bMoK5hbsDDsUEZGUUufuIzgacwt2ctVTMzlQVkFOVoSXbxzB4C4tww5LRCQlpEWNYOaq7Rwoq8CBktIKZq7aHnZIIiIpIy0SwYjurcnJiv6oDgw4plm4AYmIpJC0SASDu7Tk5RtHcN1JXTHg/WWFYYckIpIy0qKPAKLJYHCXlpSUVfDihwVcPaILPfKahB2WiEjo0qJGEOuus3rTICuDn7+VH3YoIiIpIe0SQW6THG4b05P3lmxl2nI1EYmIpF0iALh+VFc6t2rE/RPzKSuvCDscEZFQpWUiyMnM4Htn92Xplr1MmLMu7HBEREKVlokAYNyAdgzr1oqH/rGMPcWlYYcjIhKatE0EZsaPz+vPjqIDPDZ5RdjhiIiEJm0TAcCADs255MSOPDtjDQXb94cdjohIKNI6EQB85wt9yMwwHnh7SdihiIiEIu0TQZtmDbhldA/+vmiz5iASkbSU9okA4MZTutOhRUN+OnEx5RUedjgiIkmlRAA0yMrg/53dl0Ub9/CneevDDkdEJKmUCALnD2zPiZ1b8OC7S9lXUhZ2OCIiSZOwRGBmDczsIzObb2aLzOwnlZTJMbMJZrbCzGaZWddExVMVM+NH5/WncG8Jj7+/MqwwRESSLpE1ghJgjLsfD5wAjDOzEYeUuQHY6e49gf8DfpnAeKo0qHNLvnjCMTw5bRXrdxaFGYqISNIkLBF41L5gMSt4HdoTeyHwfPD+j8BYM7NExRSP747rS8Tgl39fGmYYIiJJk9A+AjPLMLNPgK3AP9191iFFOgDrANy9DNgNtK7kODeb2Rwzm1NYmNgZQ49p0ZCbT+3B3+ZvZG7BjoSeS0QkFSQ0Ebh7ubufAHQEhpnZgKM8zpPuPsTdh+Tl5dVukJUYf1p32jbL4b6J+VRoOKmI1HNJGTXk7ruAKcC4QzZtADoBmFkm0BwI/a6uRtmZfPcLfZm/bhd/nb8h7HBERBIqkaOG8sysRfC+IXAmcOg8Dm8CXwneXwJMdveU+Ap+0aAODOzYnF++s5SiAxpOKiL1VyJrBO2BKWa2AJhNtI9gopndZ2YXBGWeBlqb2QrgTuDuBMZTLZFIdDjp5j3FPDl1VdjhiIgkTMIeXu/uC4BBlaz/ccz7YuDSRMVQU0O7tuLcge154oNVXD60E+2bNww7JBGRWqc7i6tw97i+lLvzoIaTikg9pURQhU6tGnHjyd144+MNzF+3K+xwRERqnRJBHG45vSe5TXL46cTFpEhftohIrVEiiEOTnEy+84XezCnYyVufbgo7HBGRWqVEEKdLBneif/tmPPD2EopLy8MOR0Sk1igRxCkjYvzwvH5s2PUZT09fHXY4IiK1RomgGk7qkctZ/dvy2ykr2Lq3OOxwRERqhRJBNX3/nH4cKK/gV+8uCzsUEZFaoURQTV1zG3PdSV35w9x1LNywO+xwRERqTIngKNw2phctG2VrOKmI1AtKBEehecMsvnVmb2at3sG7i7aEHY6ISI0oERylK4d2onfbJjzwTj4lZRpOKiJ1lxLBUcrMiPDDc/tTsL2I5/+1JuxwRESOmhJBDZzaO4/T++TxyHsr2L6vJOxwRESOihJBDf3g3P4UlZbz0D81nFRE6iYlghrq2aYJ14zowqsfrWXp5r1hhyMiUm1KBLXgm2N70bRBFve/peGkIlL3KBHUgpaNs/nm2F5MW76NKUu3hh2OiEi1KBHUkmtGdqF7XmPufyuf0vKKsMMREYmbEkEtycqI8INz+rGqcD8vzSwIOxwRkbgpEdSiMX3bcEqvXH49aTm7ig6EHY6ISFwSlgjMrJOZTTGzxWa2yMy+WUmZ0Wa228w+CV4/TlQ8yWBm/PDc/uwtLuXXk5aHHY6ISFwSWSMoA+5y9/7ACOBWM+tfSblp7n5C8LovgfEkRZ92TblyWGdemlnAiq37wg5HRKRKCUsE7r7J3ecF7/cC+UCHRJ0vldx5Zm8aZmXw87fzww5FRKRKSekjMLOuwCBgViWbR5rZfDN7x8yOPcz+N5vZHDObU1hYmMBIa0frJjncPrYnk5dsZeqy1I9XRNJbwhOBmTUB/gTc4e57Dtk8D+ji7scDjwB/qewY7v6kuw9x9yF5eXmJDbiWfOWkrnRp3Yj731pMmYaTikgKS2giMLMsokngZXd/49Dt7r7H3fcF798GsswsN5ExJUtOZgbfO7sfy7bs47XZ68IOR0TksBI5asiAp4F8d3/oMGXaBeUws2FBPNsTFVOyfeHYtgzv1oqH/rmM3Z+Vhh2OiEilElkjGAVcA4yJGR56jpmNN7PxQZlLgIVmNh94GLjC69FkPWbGj87rz86iAzw2ZUXY4YiIVCozUQd29+mAVVHmUeDRRMWQCgZ0aM6lgzvy7IzVXDWsM11zG4cdkojI5+jO4iT49ll9yM6I8MA7Gk4qIqlHiSAJ2jRrwC2n9+TdRVv418ptYYcjIvI5SgRJcsPJ3ejQoiH3T8ynvKLedIOISD2gRJAkDbIyuPvsvizetIdbX57L3IKdYYckIgIoESTVMc0bYAZ/X7SFq56aqWQgIilBiSCJZq7e8e9hVCVlFby7aHOo8YiIgBJBUo3o3prszAiRIBv8+eP1bNz1WbhBiUjaUyJIosFdWvLyjSO466w+/M/Fx1F8oIKrnprJlj3FYYcmImksYTeUSeUGd2nJ4C4tAejRpinXPj2Lq56ayYSvjSS3SU7I0YlIOlKNIESDu7TkmeuGsnFXMVf/fhY79+vxliKSfEoEIRvevTW//8oQVm/bz9VPz2J3kSanE5HkUiJIAaN65vLENYNZvmUf1z77EXuLlQxEJHmUCFLE6D5teOzLJ7Jow26uf3Y2+0vKwg5JRNKEEkEKObN/Wx6+chAfr9vFDc/P5rMD5WGHJCJpQIkgxZxzXHseuux4Zq3ewc0vzqG4VMlARBJLiSAFXXhCB/7n4oFMW76NW16ex4EyPfNYRBJHiSBFXTqkEz+7aACTl2zl9lfnUVquZCAiiaFEkMK+PLwL957fn3cXbeFbEz6hTMlARBJAdxanuOtGdeNAeQU/f3sJ2RkRHrz0eDIiR3wCqIhItcSVCMxsFHAv0CXYxwB39+6JC00OuvnUHpSUVvCrfy4jOzPCzy86joiSgYjUknhrBE8D3wLmAhrGEoLbx/biQHkFj0xeQVZGhPsuPBYzJQMRqbl4E8Fud3+nOgc2s07AC0BbwIEn3f03h5Qx4DfAOUARcJ27z6vOedLJnWf25kBZBU9MXUV2ZoQfnttPyUBEaizeRDDFzB4E3gBKDq6s4kO7DLjL3eeZWVNgrpn9090Xx5Q5G+gVvIYDvwv+lUqYGXef3ZeSsgqenr6a7MwI3/1CHyUDEamReBPBwQ/nITHrHBhzuB3cfROwKXi/18zygQ5AbCK4EHjB3R2YaWYtzKx9sK9Uwsy45/z+HCiv4HfvryQnM8IdZ/QOOywRqcPiSgTufnpNTmJmXYFBwKxDNnUA1sUsrw/WfS4RmNnNwM0AnTt3rkko9YKZcf+FAygtq+DXk5aTnRnhltE9ww5LROqoeEcNNQfuAU4NVn0A3Ofuu+PYtwnwJ+AOd99zNEG6+5PAkwBDhgzxozlGfROJGL+4eCAHyiv4n78vJTsjwo2naBCXiFRfvE1DzwALgcuC5WuAZ4EvHWknM8simgRedvc3KimyAegUs9wxWCdxyIgYv7r0eErLK7j/rXyyMyNcO7Jr2GGJSB0TbyLo4e4Xxyz/xMw+OdIOwYigp4F8d3/oMMXeBG4zs9eI9kPsVv9A9WRmRPjNFYM4UDaPH/91EdkZEa4YpuYzEYlfvFNMfGZmJx9cCG4w+6yKfUYRrTmMMbNPgtc5ZjbezMYHZd4GVgErgKeAW6oXvgBkZUR47MuDOK13Ht/786f8ae76sEMSkTok3hrB14Hng74CA3YA1x1pB3efHpQ9UhkHbo0zBjmCnMwMnrhmMDc8P5vv/HE+2ZkRzj/+mLDDEpE6IN5RQ58Ax5tZs2D5qDp9JbEaZGXw1LVDuO6Z2dwx4ROyMoxxA9qHHZaIpLgjNg2Z2dXBv3ea2Z3AjcCNMcuSYhplZ/LM9UMZ2LE5t7/6Me/lbwk7JBFJcVX1ETQO/m1ayatJAuOSGmiSk8lz1w+jb7tmfP2leUxdVhh2SCKSwizaTF9FIbNR7j6jqnXJMGTIEJ8zZ06yT1sn7So6wJVPzWJV4T6evX4oJ/XIDTskEQmJmc119yGVbYt31NAjca6TFNKiUTYv3TCMLq0bccNzc5i9ZkfYIYlICqqqj2Ckmd0F5B3sFwhe9wIZSYlQaqR1kxxeunE47Zs34PpnZ/Px2p1hhyQiKaaqGkE20b6ATD7fP7AHuCSxoUltadO0Aa/cNIJWjbO59pmPWLihyplBRCSNxNtH0MXdC5IQT5XUR3D01u8s4vInZrL/QBmv3jSCfu2bhR2SiCRJbfQRFJnZg2b2tplNPviqxRglCTq2bMQrNw2nQWYGlz/xIff9bRFzC9RUJJLu4k0ELwNLgG7AT4A1wOwExSQJ1KV1Y75/bl/2FJfxzIw1XPHkh0oGImku3kTQ2t2fBkrd/QN3/ypHeCiNpLZ1Oz4jEkz+UVru/HTiIopL9ShqkXQVbyIoDf7dZGbnmtkgoFWCYpIEG9G9NdmZETIsOpX1J+t2c+GjM1i2ZW/YoYlICOLtLD4PmEb02QGPAM2An7j7m4kN77+ps7h2zC3YycxV2xnRvTV7i0v59uvz2VdSxo/PO5Yrh3XSc5BF6pkjdRbHlQhSiRJBYmzdW8ydE+YzfcU2zj2uPT//0nE0b5gVdlgiUkuOlAjifVRlN+B2oGvsPu5+QW0EKOFr07QBL3x1GE9MXcWv/rGUT9bt4uErBzG4S8uwQxORBIu3j+AvREcKPQL8KuYl9UgkYnx9dA9eHz8SM7jsiQ95bMoKyivqVq1RRKon3gfTFLv7wwmNRFLGoM4tefubp/D9Nz7lwXeX8q+V23joshNo26xB2KGJSALEWyP4jZndE8w9dOLBV0Ijk1A1a5DFI1cO4pcXH8fcgp2c/ZtpTFmyNeywRCQB4q0RHEfw/GGgIljn6F6Ces3MuHxoZwZ3acltr3zM9c/N5oaTu/HdcX3IydScgyL1RbyJ4FKgu7sfSGQwkpp6tmnKX24dxQNv5/P09NXMWr2dR648kW65javeWURSXrxNQwuBFtU5sJk9Y2ZbzWzhYbaPNrPdZvZJ8PpxdY4vydUgK4OfXDiAJ68ZzPqdn3Hew9N4Y976sMMSkVoQb42gBbDEzGYDJQdXVjF89DngUeCFI5SZ5u7nxRmDpICzjm3HgA7NuWPCJ9z5h/lMX76N+744gCY58f4piUiqifd/7z3VPbC7TzWzrtXdT1LfMS0a8upNI3hk8nIefm8589bu5JErT+S4js3DDk1EjkKVTUNmlgE8EUw297lXLZx/pJnNN7N3zOzYWjieJElGxLjjjN68etMISsoq+NLvZvD7aauoa3eqi0gcicDdy4GlZta5ls89D+ji7scTvVHtL4craGY3m9kcM5tTWFhYy2FITQzv3pq3v3EKo/u04f638vnqc7PZvq+k6h1FJGXEO+ncVGAQ8BGw/+D6qqaYCJqGJrr7gDjOsQYY4u7bjlROcw2lJnfnxZkF3P9WPi0aZvHry0/gpJ65YYclIoEazzUE/KgW4wHAzNoBW9zdzWwY0drJ9to+jySHmXHtyK4M6dKK21+dx5efnsUto3twxxm9ycqId3CaiIQhrv+hQX/AEv7z8Pr8qvoIzOxV4EOgj5mtN7MbzGy8mY0PilwCLDSz+cDDwBWuBuY6r/8xzfjb7Sdz2eBOPDZlJZc/8SHrdhSFHZaIHEG8TUOXAQ8C7wMGnAJ8x93/mNDoKqGmobrjb/M38v03PgWDX3xpIOcObB92SCJpqzaahn4ADHX3rcEB84BJQNITgdQd5x9/DMd3bME3XvuYW1+Zx/QVnfnxef1pmK3pKURSSbyNt5GDSSCwvRr7Shrr3LoRr48fyfjTevDqR2u54NHpLN2sR2KKpJJ4P8z/bmbvmtl1ZnYd8BbwduLCkvokKyPC3Wf35cUbhrGzqJQLHp3OSzMLdM+BSIo4Yh+BmeW4e0nw/kvAycGmae7+5yTE91/UR1C3Fe4t4a7X5zN1WSHjjm3HVcM68+nG3Yzo3lpPQxNJoKN+ZrGZzXP3E83sRXe/JmERVoMSQd1XUeE8PX01v3gnn3KHiEF2ZoSXbxyhZCCSIDXpLM42s6uAk4Iawee4+xu1EaCkl0jEuOnU7qzdUcSLMwuocCgureCdhZuUCERCUFUiGA98mejso+cfss0BJQI5al8c1IHX56yjpKwCB56dsRp3+MaYXjRvlBV2eCJpI977CG5w96eTEE+V1DRUv8wt2MnMVdvp064pkxZvYcKcdbRomMUdZ/TmquGddVeySC056j6CQw5yEtCVmFqEux/pWQMJoURQvy3euIf731rMv1Zup0deY354bn9G98nDzMIOTaROO1IiiOvrlpm9CPwv0VFDQ4NXpQcUqYn+xzTj5RuH89S1Q6hwuP652Vz7zEe690AkgeJtGsoH+qfCXECqEaSPA2UVvDizgN9MWsa+kjKuHNaZO8/sTesmOWGHJlLn1LhGQPSZxe1qLySRqmVnRrjh5G588J3TuXZkV16bvY7RD77PEx+spKSsPOzwROqNeGsEU4ATiD6PIN5nFieEagTpa8XWffz87XwmL9lK51aN+N7ZfRk3oJ36D0TiUOPOYjM7rbL1tfS4ympRIpBpywu5f2I+S7fsZVi3Vvzo3P56XrJIFWpl1FCqUCIQgLLyCibMWcdD/1jGjqIDfGlQR747rg9tmzUIOzSRlFSTKSb2Er1x7L82Ae7uzWonxPgpEUisPcWlPDZlBc9OX0NGxBh/Wg9uPrW7proWOYRqBFLvrd1exC/+ns/bn26mffMGfHdcHy48vgORiPoPRKB2Rg2JpLTOrRvx2y8P5g9fG0lukxy+NWE+F/12BnPW7Ag7NJGUp0Qg9cqwbq34662j+NWlx7N5TzGXPP4ht74yT89NFjkCJQKpdyIR4+LBHZny7dF8c2wv3svfwtiHPuCXf1/C3uLSsMMTSTlKBFJvNcrO5Ftn9mbKt0dz3nHt+d37Kzn9f9/n1Y/WUl5Rt/rGRBIpYYnAzJ4xs61mtvAw283MHjazFWa2wMxOTFQskt7aN2/IQ5efwF9vHUXX1o353hufcu7D05ixYlvYoYmkhETWCJ4Dxh1h+9lAr+B1M/C7BMYiwvGdWvD6+JE8etUg9pWU8eXfz+LG52ezqnAfcwt28tiUFcwt2Bl2mCJJV9WDaY6au081s65HKHIh8EIwkd1MM2thZu3dfVOiYhIxM84beAxn9GvLMzNW89spKznzoQ/ADHfXIzMlLYXZR9ABWBezvD5Y91/M7GYzm2NmcwoLC5MSnNRvDbIyuGV0T6Z8ezTHdmhOeYVT4VBSWsG7CzeHHZ5IUtWJzmJ3f9Ldh7j7kLy8vLDDkXokr2kO95x/LDmZkejt8sBT01Zx2yvzWLhhd9jhiSRFwpqG4rAB6BSz3DFYJ5JUg7u05JWbRkQfmdm2KbPX7ODlWWuZuGATJ/fM5Wundefknrma5VTqrYROMRH0EUx09wGVbDsXuA04BxgOPOzuw6o6pqaYkGTYU1zKK7PW8sz01WzdW8KxxzTja6f14JwB7cjUc5SlDgplriEzexUYDeQCW4B7gCwAd3/col+vHiU6sqgIuN7dq/yEVyKQZCopK+cvH2/giamrWFW4n06tGnLTKd25dHAnTWwndYomnROpoYoK55/5W3j8g5V8vHYXrRpn85WRXbl2ZBdaNs4OOzyRKikRiNQSd2f2mp08/sFKJi/ZSsOsDC4f2okbT+lGx5aNwg5P5LCOlAjC7CwWqXPMjGHdWjGsWyuWbt7LE1NX8tLMAl6cWcD5A9vztdN60K990h/TIVIjqhGI1NDGXZ/x9PTVvPrRWooOlHNa7zzGn9aDEd1baaSRpAw1DYkkwe6iUl6cuYZnZ6xh+/4DHN+xOeNP68FZx7YjQw/IkZApEYgkUXFpOX+cu56npq2iYHsRXVs34qZTu3PxiR1pkKWRRhIOJQKREJRXOH9fuJnHP1jJpxt2k9skh+tHdeXq4V1o3igr7PAkzSgRiITI3flw5XYen7qKqcsKaZydwZXDOnPDKd1o37xh2OFJmlAiEEkRizbu5smpq5i4YBMGXHhCB8af1p1ebZuGHZrUc0oEIilm3Y4ifj9tFRPmrKO4tIKxfdswfnQPImbMXLWdEd1baypsqVVKBCIpasf+A7zw4Rqe/9cadhaVYsEUqDmZEV6+Sc9FkNpzpESg2bNEQtSqcTZ3nNGbGXePYWy/NrhHp8IuLqvgZ28tZvHGPWGHKGlAiUAkBTTKzuSW0T1pkBUhYhAxWLB+N+c8PI0LHp3Oy7MK2FtcGnaYUk+paUgkhcwt2PnvPoLuuY35yycbeO2jdSzdspeGWRmcN7A9VwzrxImdW+quZakW9RGI1GHuzvz1u3nto7W8OX8jRQfK6dmmCVcM7cRFgzrQuklO2CFKHaBEIFJP7Csp460FG3lt9qRRTjgAAA8ESURBVDo+XruLrAzjrP7tuGJYJ0b1yCWiqSzkMJQIROqhpZv3MmH2Ot74eD27ikrp0KIhlw/txKVDOupGNfkvSgQi9VhxaTn/WLyFCbPXMmPFdiIGp/XO4/KhnRnbrw1ZerSmoEQgkjbWbi/iD3PW8frcdWzZU0JukxwuGdyRy4d2oltu47DDkxApEYikmbLyCj5YVsirH61jytKtlFc4w7u14ophnTh7QHvNgpqGlAhE0tiWPcX8ce56Jsxex9odRTRrkMlFgzpw+dDO9D9GT1NLF0oEIkJFhTNz9XYmzF7HOws3c6CsgoEdm3P50E5ccPwxNG2gqbHrs9ASgZmNA34DZAC/d/dfHLL9OuBBYEOw6lF3//2RjqlEIFJzu4oO8OePK79ZDYeZq3do4rt6JpREYGYZwDLgTGA9MBu40t0Xx5S5Dhji7rfFe1wlApHac/BmtQmz1/LmJxvZf6Ccg3ciZGdGeEUT39UbYU06NwxY4e6r3P0A8BpwYQLPJyLVZGac0KkFD3xpIB/94AzGHdsOJzrxXUlZBd94dR7PzVjN1j3FYYcqCZTIRNABWBezvD5Yd6iLzWyBmf3RzDpVdiAzu9nM5pjZnMLCwkTEKpL2GudkctOp3f898V1mxMiwCPf+bTHDH3iPK578kJdmFrBtX0nYoUotS2TT0CXAOHe/MVi+Bhge2wxkZq2Bfe5eYmZfAy539zFHOq6ahkQSK3biu8FdWrJ8y14mLtjExAUbWVm4n4yIMbJ7a84b2J5xA9rRolF22CFLHMLqIxgJ3OvuXwiWvwfg7g8cpnwGsMPdmx/puEoEIuFwd5Zs3svEBRuZuGATBduLyIwYJ/fK5dzj2nPWse1o3lAjj1JVWIkgk2hn8Viio4JmA1e5+6KYMu3dfVPw/iLg/7n7iCMdV4lAJHzuzqKNe/jbgo28tWAT63d+RnZGhFN753LewGM4o39bmuRkhh2mxDhSIkjYb8rdy8zsNuBdosNHn3H3RWZ2HzDH3d8EvmFmFwBlwA7gukTFIyK1x8wY0KE5Azo05+5xfZm/fjcT52/krU83MSl/KzmZEU7v04ZzB7ZnbL82NMpWUkhluqFMRGpNRYUzb+1OJi7YxFufbqJwbwkNszIY068N5w9sz+g+bTS9RUh0Z7GIJF15hTN7zQ4mLtjIO59uZvv+AzTOzuCM/m05b+AxnNo7l5xMJYVkUSIQkVCVlVcwc9UO3vp0I+8s3MyuolKaNsjkrP7tOO/49ozqkUt2pqbLTiQlAhFJGaXlFcxYsY2JCzbx7qLN7C0uo3nDLMYdG00KI7u3JlPPUKh1SgQikpJKysqZvjyaFP65eAv7Sspo3TibcQPa0attE/YVlzGyR66muagFoYwaEhGpSk5mBmP7tWVsv7YUl5bzwbJCJi7YxB/nrqekrAKADFvOXWf14tqTumlIaoKoRiAiKec3k5bx60nLif10ys6IMLx7K87o15YxfdvQqVWj0OKri1QjEJE65eReefzug5WUllWQlRnh++f0Y/3Oz5iUv4V73lzEPW8uok/bpozp14Yz+rXhhE4tyYhY1QeWSqlGICIp6dA5jw5avW0/7+VvYfKSrXy0egdlFU6rxtmM7pPH2L5tObV3rh6yUwl1FotIvbT7s1KmLitk8pKtTFm6lV1FpWRlGMO6tWJs37aM7deGLq0bhx1mSlAiEJF6r6y8go/X7WJS/hYm529l+dZ9APRs04Sxfdswtl9bTuzcIm2HpioRiEjaKdi+n8lLtvJe/lZmrd5OabnTolEWo3vnMaZfW07rnZdWs6UqEYhIWttbXMq05duYlL+F95cWsmP/ATIjxtCurRjbL1pb6JZbv5uQlAhERALlFc4n63YyKX8rk/O3snTLXgC65zZmbL82jOnbliFdW5JVz5qQlAhERA5j3Y4iJi/ZyqT8LcxatYMD5RU0a5DJaX2iQ1NbNMxi4cY9/zV6qa5RIhARicO+kjKmLy9kUv5WpizZyvb9B/69LTNi/OSCY7lsaKc6WVtQIhARqaaKCudHf13IK7PWfu4O5yY5mYzo3oqTe+Zycq9ceuQ1wSz1b2bTncUiItUUiRhfOrEjf5q3ntKyCjIzItw+picbdxczffk2JuVvBaBdswaM6pnLKb1yOalna9o0bRBy5NWnRCAichiDu7Tk5RtHVHqH89rtRUxfsY0ZK7bx3pIt/GneegD6tmvKqJ65nNwzl+HdW9WJx3SqaUhEpIYqKpxFG/cwfcU2pq8oZPaanRwoqyArwxjUuSWn9MxlVK9cBnZoHtoNbeojEBFJouLScmav2RFNDMu3sWjjHgCaNshkZPfWnNIrl1E9c+mW2zhp/QvqIxARSaIGWRmc0iuPU3rlwdmwfV8J/1q5nRkrtjFt+Tb+sXgLAB1aNGRUz9ac3CuPUT1a07pJTijxJrRGYGbjgN8AGcDv3f0Xh2zPAV4ABgPbgcvdfc2RjqkagYjUZe5OwfYipq3Yxozl2/jXym3sKS4DoH/7ZpzcK9q/MLRrKxpmZ9TaeUNpGjKzDGAZcCawHpgNXOnui2PK3AIMdPfxZnYFcJG7X36k4yoRiEh9Ul7hfLphN9OXFzJ9xTbmFuyktNzJzogwpGvLf49IKimr4KPVO476xrawEsFI4F53/0Kw/D0Ad38gpsy7QZkPzSwT2Azk+RGCUiIQkfqs6EAZH63e8e9mpCWb9/57mwE5WRFevnFEtZNBWH0EHYB1McvrgeGHK+PuZWa2G2gNbIstZGY3AzcDdO7cOVHxioiErlF2JqP7tGF0nzYAFO4t4Sd/W8TEBZtwoLSsgpmrttfqdBd14j5pd3/S3Ye4+5C8vLywwxERSZq8pjlcP6obDbIiZBhkZUYY0b11rZ4jkTWCDUCnmOWOwbrKyqwPmoaaE+00FhGRwJFubKsNiUwEs4FeZtaN6Af+FcBVh5R5E/gK8CFwCTD5SP0DIiLpanCXlgmb/TRhiSBo878NeJfo8NFn3H2Rmd0HzHH3N4GngRfNbAWwg2iyEBGRJEroDWXu/jbw9iHrfhzzvhi4NJExiIjIkdWJzmIREUkcJQIRkTSnRCAikuaUCERE0lydm4bazAqBgrDjqKFcDrl7Os3penyersd/6Fp8Xk2uRxd3r/SO3DqXCOoDM5tzuDk/0pGux+fpevyHrsXnJep6qGlIRCTNKRGIiKQ5JYJwPBl2AClG1+PzdD3+Q9fi8xJyPdRHICKS5lQjEBFJc0oEIiJpTokggcxsnJktNbMVZnZ3JdvvNLPFZrbAzN4zsy5hxJksVV2PmHIXm5mbWb0dNhjPtTCzy4K/j0Vm9kqyY0ymOP6vdDazKWb2cfD/5Zww4kwGM3vGzLaa2cLDbDczezi4VgvM7MQan9Td9UrAi+jU2yuB7kA2MB/of0iZ04FGwfuvAxPCjjvM6xGUawpMBWYCQ8KOO8S/jV7Ax0DLYLlN2HGHfD2eBL4evO8PrAk77gRej1OBE4GFh9l+DvAO0UcYjwBm1fScqhEkzjBghbuvcvcDwGvAhbEF3H2KuxcFizOJPsWtvqryegR+CvwSKE5mcEkWz7W4CXjM3XcCuPvWJMeYTPFcDweaBe+bAxuTGF9SuftUos9nOZwLgRc8aibQwsza1+ScSgSJ0wFYF7O8Plh3ODcQzfL1VZXXI6jidnL3t5IZWAji+dvoDfQ2sxlmNtPMxiUtuuSL53rcC1xtZuuJPuPk9uSElpKq+9lSpYQ+mEbiY2ZXA0OA08KOJSxmFgEeAq4LOZRUkUm0eWg00ZriVDM7zt13hRpVeK4EnnP3X5nZSKJPNhzg7hVhB1YfqEaQOBuATjHLHYN1n2NmZwA/AC5w95IkxRaGqq5HU2AA8L6ZrSHa9vlmPe0wjudvYz3wpruXuvtqYBnRxFAfxXM9bgD+AODuHwINiE7Alo7i+mypDiWCxJkN9DKzbmaWTfR5zG/GFjCzQcATRJNAfW4Dhiquh7vvdvdcd+/q7l2J9plc4O5zwgk3oar82wD+QrQ2gJnlEm0qWpXMIJMonuuxFhgLYGb9iCaCwqRGmTreBK4NRg+NAHa7+6aaHFBNQwni7mVmdhvwLtFREc+4+yIzuw+Y4+5vAg8CTYDXzQxgrbtfEFrQCRTn9UgLcV6Ld4GzzGwxUA58x923hxd14sR5Pe4CnjKzbxHtOL7OgyE09Y2ZvUr0S0Bu0CdyD5AF4O6PE+0jOQdYARQB19f4nPX0WoqISJzUNCQikuaUCERE0pwSgYhImlMiEBFJc0oEIiJpTolA0oKZlZvZJ2a20MxeN7NG1dj3OjN7tJrn23eY9fcFNxFiZu8fvGHOzN42sxbB65bqnEukppQIJF185u4nuPsA4AAwPnajmSXlnhp3/7G7T6pk/TnB9BEtACUCSSolAklH04CeZjbazKaZ2ZvAYjNrYGbPmtmnwbz3p8fs0yn4Br/czO45uNLM/mJmc4NnBtwcexIz+79g/Xtmlhese87MLjk0IDNbE9xB/AugR1B7edDMXjCzL8aUe9nMKpu1VeSoKRFIWgm++Z8NfBqsOhH4prv3Bm4F3N2PIzrJ2fNm1iAoNwy4GBgIXBozB9JX3X0w0UkDv2FmrYP1jYneFXss8AHRu0PjcTewMqi9fAd4mmAiPjNrDpwE1PfZWSXJlAgkXTQ0s0+AOUTnrXk6WP9RMKkbwMnASwDuvgQoIDrHD8A/3X27u38GvBGUheiH/3yicyN14j8Tw1UAE4L3L8WUrxZ3/4DoPDx5RJPTn9y97GiOJXI4mmtI0sVn7n5C7Ipgfqf9ce5/6FwsbmajgTOAke5eZGbvE50MLZ79q+MF4Gqik7HVeF4ZkUOpRiDyH9OALwOYWW+gM7A02HammbUys4bAF4EZRJ+UtTNIAn2JTp19UAQ42BdwFTA9zhj2Ep2SO9ZzwB0A7r64Oj+QSDyUCET+47dAxMw+Jdqsc13MMyI+Av4ELCDaPDMH+DuQaWb5RDt5Z8Ycaz8wLHgA+RjgvngCCGYYnREMc30wWLcFyAeerekPKFIZzT4qkuKCex4+BU50991hxyP1j2oEIiksuPksH3hESUASRTUCEZE0pxqBiEiaUyIQEUlzSgQiImlOiUBEJM0pEYiIpLn/DwJVIuIOVnAeAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uff5x71mXAPM"
      },
      "source": [
        "## Calculate the Entropy for a Random Variable\n",
        "\n",
        "We can also quantify how much information there is in a random variable.\n",
        "\n",
        "For example, if we wanted to calculate the information for a random variable X with probability distribution p, this might be written as a function H(); for example:\n",
        "\n",
        "$$\n",
        "H(X)\n",
        "$$\n",
        "In effect, calculating the information for a random variable is the same as calculating the information for the probability distribution of the events for the random variable.\n",
        "\n",
        "Calculating the information for a random variable is called “information entropy,” “Shannon entropy,” or simply “entropy“. It is related to the idea of entropy from physics by analogy, in that both are concerned with uncertainty.\n",
        "\n",
        "The intuition for entropy is that it is the average number of bits required to represent or transmit an event drawn from the probability distribution for the random variable.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "the Shannon entropy of a distribution is the expected amount of information\n",
        " in an event drawn from that distribution. \n",
        " It gives a lower bound on the number of bits […]\n",
        "  needed on average to encode symbols drawn from a distribution P.\n",
        "\n",
        "— Page 74, Deep Learning, 2016.\n",
        "```\n",
        "\n",
        "Entropy can be calculated for a random variable X with k in K discrete states as follows:\n",
        "$$\n",
        "H(X) = -\\sum_k( p(k) * log_2(p(k)))\n",
        "$$\n",
        "That is the negative of the sum of the probability of each event multiplied by the log of the probability of each event.\n",
        "\n",
        "Like information, the log() function uses base-2 and the units are bits. A natural logarithm can be used instead and the units will be nats.\n",
        "\n",
        "The lowest entropy is calculated for a random variable that has a single event with a probability of 1.0, a certainty. The largest entropy for a random variable will be if all events are equally likely.\n",
        "\n",
        "**example:**\n",
        "\n",
        "We can consider a roll of a fair die and calculate the entropy for the variable. Each outcome has the same probability of 1/6, therefore it is a uniform probability distribution. We therefore would expect the average information to be the same information for a single event calculated in the previous section.\n",
        "\n",
        "Running the example calculates the entropy as more than 2.5 bits, which is the same as the information for a single outcome. This makes sense, as the average information is the same as the lower bound on information as all outcomes are equally likely.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "apC3QyQ5XJcz",
        "outputId": "adcb4566-3736-44bb-e0d8-272e10bec156"
      },
      "source": [
        "# calculate the entropy for a dice roll\n",
        "from math import log2\n",
        "# the number of events\n",
        "n = 6\n",
        "# probability of one event\n",
        "p = 1.0 /n\n",
        "# calculate entropy\n",
        "entropy = -sum([p * log2(p) for _ in range(n)])\n",
        "# print the result\n",
        "print('entropy: %.3f bits' % entropy)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "entropy: 2.585 bits\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jj0IIZ9WYcZ8"
      },
      "source": [
        "If we know the probability for each event, we can use the entropy() SciPy function to calculate the entropy directly.\n",
        "\n",
        "Running the example reports the same result that we calculated manually.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "10WLsfhgYd4S",
        "outputId": "d16cfd72-56f0-4585-8254-0db8b5ef30f2"
      },
      "source": [
        "# calculate the entropy for a dice roll\n",
        "from scipy.stats import entropy\n",
        "# discrete probabilities\n",
        "p = [1/6, 1/6, 1/6, 1/6, 1/6, 1/6]\n",
        "# calculate entropy\n",
        "e = entropy(p, base=2)\n",
        "# print the result\n",
        "print('entropy: %.3f bits' % e)\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "entropy: 2.585 bits\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ShsGGeHYus_"
      },
      "source": [
        "We can further develop the intuition for entropy of probability distributions.\n",
        "\n",
        "Recall that entropy is the number of bits required to represent a randomly drawn even from the distribution, e.g. an average event. We can explore this for a simple distribution with two events, like a coin flip, but explore different probabilities for these two events and calculate the entropy for each.\n",
        "\n",
        "In the case where one event dominates, such as a skewed probability distribution, then there is less surprise and the distribution will have a lower entropy. In the case where no event dominates another, such as equal or approximately equal probability distribution, then we would expect larger or maximum entropy.\n",
        "\n",
        "* Skewed Probability Distribution (unsurprising): Low entropy.\n",
        "* Balanced Probability Distribution (surprising): High entropy.\n",
        "\n",
        "If we transition from skewed to equal probability of events in the distribution we would expect entropy to start low and increase, specifically from the lowest entropy of 0.0 for events with impossibility/certainty (probability of 0 and 1 respectively) to the largest entropy of 1.0 for events with equal probability.\n",
        "\n",
        "The example below implements this, creating each probability distribution in this transition, calculating the entropy for each and plotting the result.\n",
        "\n",
        "Running the example creates the 6 probability distributions with [0,1] probability through to [0.5,0.5] probabilities.\n",
        "\n",
        "As expected, we can see that as the distribution of events changes from skewed to balanced, the entropy increases from minimal to maximum values.\n",
        "\n",
        "That is, if the average event drawn from a probability distribution is not surprising we get a lower entropy, whereas if it is surprising, we get a larger entropy.\n",
        "\n",
        "We can see that the transition is not linear, that it is super linear. We can also see that this curve is symmetrical if we continued the transition to [0.6, 0.4] and onward to [1.0, 0.0] for the two events, forming an inverted parabola-shape.\n",
        "\n",
        "Note we had to add a tiny value to the probability when calculating the entropy to avoid calculating the log of a zero value, which would result in an infinity on not a number.\n",
        "\n",
        "\n",
        "Calculating the entropy for a random variable provides the basis for other measures such as mutual information (information gain).\n",
        "\n",
        "Entropy also provides the basis for calculating the difference between two probability distributions with cross-entropy and the KL-divergence.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "grptlpxsYysz",
        "outputId": "b9ffe83b-64eb-4ba2-fba1-1bbbe965982c"
      },
      "source": [
        "from math import log2\n",
        "from matplotlib import pyplot\n",
        " \n",
        "# calculate entropy\n",
        "def entropy(events, ets=1e-15):\n",
        "\treturn -sum([p * log2(p + ets) for p in events])\n",
        " \n",
        "# define probabilities\n",
        "probs = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]\n",
        "# create probability distribution\n",
        "dists = [[p, 1.0 - p] for p in probs]\n",
        "# calculate entropy for each distribution\n",
        "ents = [entropy(d) for d in dists]\n",
        "# plot probability distribution vs entropy\n",
        "pyplot.plot(probs, ents, marker='.')\n",
        "pyplot.title('Probability Distribution vs Entropy')\n",
        "pyplot.xticks(probs, [str(d) for d in dists])\n",
        "pyplot.xlabel('Probability Distribution')\n",
        "pyplot.ylabel('Entropy (bits)')\n",
        "pyplot.show()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mkAYQ7VNbAzC"
      },
      "source": [
        "## Cross Entropy (todo)\n",
        "\n",
        "Todo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BFspqV6kbEjy"
      },
      "source": [
        "## KL-divergence. (todo)\n",
        "\n",
        "Todo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A1_xkVGxaFN9"
      },
      "source": [
        "## Reading\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DIud-TJRZ0On"
      },
      "source": [
        "* [Information Theory, Inference, and Learning Algorithms, 2003.\n",
        "](https://amzn.to/2KfDDF7)\n",
        "* [Section 2.8: Information theory, Machine Learning: A Probabilistic Perspective, 2012.\n",
        "](https://amzn.to/2xKSTCP)\n",
        "* [Section 1.6: Information Theory, Pattern Recognition and Machine Learning, 2006.\n",
        "](https://amzn.to/2JwHE7I)\n",
        "* [Section 3.13 Information Theory, Deep Learning, 2016.\n",
        "](https://amzn.to/2lnc3vL)\n",
        "* https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.entropy.html\n",
        "\n"
      ]
    }
  ]
}