{ "cells": [ { "cell_type": "markdown", "metadata": { "toc": "true" }, "source": [ "# Table of Contents\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# A short study of Rényi entropy\n", "\n", "I want to study here the Rényi entropy, using [Python](https://www.python.org/).\n", "I will define a function implementing $H_{\\alpha}(X)$, from the given formula, for discrete random variables, and check the influence of the parameter $\\alpha$,\n", "$$ H_{\\alpha}(X) := \\frac{1}{1-\\alpha} \\log_2(\\sum_i^n p_i^{\\alpha}),$$\n", "where $X$ has $n$ possible values, and the $i$-th outcome has probability $p_i\\in[0,1]$.\n", "\n", "- *Reference*: [this blog post by John D. Cook](https://www.johndcook.com/blog/2018/11/21/renyi-entropy/), [this Wikipédia page](https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy) and [this page on MathWorld](http://mathworld.wolfram.com/RenyiEntropy.html),\n", "- *Author*: [Lilian Besson](https://perso.crans.org/besson/)\n", "- *License*: [MIT License](https://lbesson.mit-license.org/)\n", "- *Date*: 22th of November, 2018" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Requirements" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "code_folding": [], "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: watermark in /usr/local/lib/python3.6/dist-packages (1.5.0)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (3.0.2)\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (1.14.5)\n", "Requirement already satisfied: ipython in /usr/local/lib/python3.6/dist-packages (from watermark) (7.0.1)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (0.10.0)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (2.3.0)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (2.7.3)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib) (1.0.1)\n", "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (40.5.0)\n", "Requirement already satisfied: prompt-toolkit<2.1.0,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (2.0.4)\n", "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (4.3.2)\n", "Requirement already satisfied: pygments in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (2.2.0)\n", "Requirement already satisfied: pickleshare in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (0.7.5)\n", "Requirement already satisfied: decorator in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (4.3.0)\n", "Requirement already satisfied: jedi>=0.10 in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (0.12.1)\n", "Requirement already satisfied: pexpect; sys_platform != \"win32\" in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (4.6.0)\n", "Requirement already satisfied: simplegeneric>0.8 in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (0.8.1)\n", "Requirement already satisfied: backcall in /usr/local/lib/python3.6/dist-packages (from ipython->watermark) (0.1.0)\n", "Requirement already satisfied: six in /home/lilian/.local/lib/python3.6/site-packages (from cycler>=0.10->matplotlib) (1.11.0)\n", "Requirement already satisfied: wcwidth in /usr/local/lib/python3.6/dist-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython->watermark) (0.1.7)\n", "Requirement already satisfied: ipython-genutils in /usr/local/lib/python3.6/dist-packages (from traitlets>=4.2->ipython->watermark) (0.2.0)\n", "Requirement already satisfied: parso>=0.3.0 in /usr/local/lib/python3.6/dist-packages (from jedi>=0.10->ipython->watermark) (0.3.1)\n", "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.6/dist-packages (from pexpect; sys_platform != \"win32\"->ipython->watermark) (0.6.0)\n" ] } ], "source": [ "!pip install watermark matplotlib numpy" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The watermark extension is already loaded. To reload it, use:\n", " %reload_ext watermark\n", "Lilian Besson \n", "\n", "CPython 3.6.6\n", "IPython 7.0.1\n", "\n", "matplotlib 3.0.2\n", "numpy 1.14.5\n", "\n", "compiler : GCC 8.0.1 20180414 (experimental) [trunk revision 259383\n", "system : Linux\n", "release : 4.15.0-38-generic\n", "machine : x86_64\n", "processor : x86_64\n", "CPU cores : 4\n", "interpreter: 64bit\n", "Git hash : a119f96f2de5b449131a73b6c9861f26b2c0d3f8\n" ] } ], "source": [ "%load_ext watermark\n", "%watermark -v -m -a \"Lilian Besson\" -g -p matplotlib,numpy" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "----\n", "## Utility functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start by giving three examples of such vectors $X=(p_i)_{1\\leq i \\leq n}$, a discrete probability distributions on $n$ values." ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "X1 = [0.25, 0.5, 0.25]\n", "X2 = [0.1, 0.25, 0.3, 0.45]\n", "X3 = [0, 0.5, 0.5]\n", "\n", "X4 = np.full(100, 1/100)\n", "X5 = np.full(1000, 1/1000)\n", "\n", "X6 = np.arange(100, dtype=float)\n", "X6 /= np.sum(X6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need a function to safely compute $x \\mapsto x \\log_2(x)$, with special care in case $x=0$. This one will accept a numpy array or a single value as argument:" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.seterr(all=\"ignore\")" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [], "source": [ "def x_log2_x(x):\n", " \"\"\" Return x * log2(x) and 0 if x is 0.\"\"\"\n", " results = x * np.log2(x)\n", " if np.size(x) == 1:\n", " if np.isclose(x, 0.0):\n", " results = 0.0\n", " else:\n", " results[np.isclose(x, 0.0)] = 0.0\n", " return results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For examples:" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "-0.5" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "0.0" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "2.0" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "33.219280948873624" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x_log2_x(0)\n", "x_log2_x(0.5)\n", "x_log2_x(1)\n", "x_log2_x(2)\n", "x_log2_x(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and with vectors, slots with $p_i=0$ are handled without error:" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/plain": [ "array([-0.5, -0.5, -0.5])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "array([-0.33219281, -0.5 , -0.52108968, -0.51840139])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "array([ 0. , -0.5, -0.5])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "array([-0.06643856, -0.06643856, -0.06643856, -0.06643856, -0.06643856,\n", " -0.06643856, -0.06643856, -0.06643856, -0.06643856, -0.06643856])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "array([-0.00996578, -0.00996578, -0.00996578, -0.00996578, -0.00996578,\n", " -0.00996578, -0.00996578, -0.00996578, -0.00996578, -0.00996578])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": [ "array([ 0. , -0.00247944, -0.00455483, -0.00647773, -0.00830159,\n", " -0.0100518 , -0.01174333, -0.01338606, -0.01498701, -0.01655143])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x_log2_x(X1)\n", "x_log2_x(X2)\n", "x_log2_x(X3)\n", "\n", "x_log2_x(X4)[:10]\n", "x_log2_x(X5)[:10]\n", "x_log2_x(X6)[:10]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "----\n", "## Definition, common and special cases" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the mathematical definition, an issue will happen if $\\alpha=1$ or $\\alpha=\\inf$, so we deal with the special cases manually.\n", "$X$ is here given as the vector of $(p_i)_{1\\leq i \\leq n}$." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "def renyi_entropy(alpha, X):\n", " assert alpha >= 0, \"Error: renyi_entropy only accepts values of alpha >= 0, but alpha = {}.\".format(alpha) # DEBUG\n", " if np.isinf(alpha):\n", " # XXX Min entropy!\n", " return - np.log2(np.max(X))\n", " elif np.isclose(alpha, 0):\n", " # XXX Max entropy!\n", " return np.log2(len(X))\n", " elif np.isclose(alpha, 1):\n", " # XXX Shannon entropy!\n", " return - np.sum(x_log2_x(X))\n", " else:\n", " return (1.0 / (1.0 - alpha)) * np.log2(np.sum(X ** alpha))" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "# Curryfied version\n", "def renyi_entropy_2(alpha):\n", " def re(X):\n", " return renyi_entropy(alpha, X)\n", " return re" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "# Curryfied version\n", "def renyi_entropy_3(alphas, X):\n", " res = np.zeros_like(alphas)\n", " for i, alpha in enumerate(alphas):\n", " res[i] = renyi_entropy(alpha, X)\n", " return res" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "----\n", "## Plotting some values" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [], "source": [ "alphas = np.linspace(0, 10, 1000)" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1.5849625 , 1.58414417, 1.58332491, 1.58250473, 1.58168363,\n", " 1.58086162, 1.58003871, 1.5792149 , 1.57839021, 1.57756464])" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "renyi_entropy_3(alphas, X1)[:10]" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [], "source": [ "def plot_renyi_entropy(alphas, X):\n", " fig = plt.figure()\n", " plt.plot(alphas, renyi_entropy_3(alphas, X))\n", " plt.xlabel(r\"Value for $\\alpha$\")\n", " plt.ylabel(r\"Value for $H_{\\alpha}(X)$\")\n", " plt.title(r\"Réniy entropy for $X={}$\".format(X[:10]))\n", " plt.show()\n", " # return fig" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "