{"cells":[{"cell_type":"markdown","metadata":{"colab_type":"text","id":"s6fcBsTwHFl4"},"source":["# 2023 Oct 6th, Tutorial 3\n","# Model Types: \"Why\" models\n","\n","We would like to acknowledge [Steinmetz _et al._ (2019)](https://www.nature.com/articles/s41586-019-1787-x) for sharing their data, a subset of which is used here.\n"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"6_QA4D6NlsYQ"},"source":["___\n","# Tutorial Objectives\n","This is tutorial 3 of a 3-part series on different flavors of models used to understand neural data. In parts 1 and 2 we explored mechanisms that would produce the data. In this tutorial we will explore models and techniques that can potentially explain *why* the spiking data we have observed is produced the way it is.\n","\n","To understand why different spiking behaviors may be beneficial, we will learn about the concept of entropy. Specifically, we will:\n","\n","- Write code to compute formula for entropy, a measure of information\n","- Compute the entropy of a number of toy distributions\n","- Compute the entropy of spiking activity from the Steinmetz dataset"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"YOCsVZYBhDMi"},"source":["# Setup"]},{"cell_type":"code","execution_count":1,"metadata":{"cellView":"both","colab":{},"colab_type":"code","executionInfo":{"elapsed":865,"status":"ok","timestamp":1594640291589,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"83AqE2hlg9H-"},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt\n","from scipy import stats"]},{"cell_type":"code","execution_count":2,"metadata":{"cellView":"form","colab":{},"colab_type":"code","executionInfo":{"elapsed":784,"status":"ok","timestamp":1594640293892,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"8JoE4VXAgKcA"},"outputs":[],"source":["#@title Figure Settings\n","import ipywidgets as widgets #interactive display\n","\n","%matplotlib inline\n","%config InlineBackend.figure_format = 'retina'\n"]},{"cell_type":"code","execution_count":3,"metadata":{"cellView":"form","colab":{},"colab_type":"code","executionInfo":{"elapsed":849,"status":"ok","timestamp":1594640296013,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"Iy0sXQdwO7vl"},"outputs":[],"source":["#@title Helper Functions\n","\n","def plot_pmf(pmf,isi_range):\n","  \"\"\"Plot the probability mass function.\"\"\"\n","  ymax = max(0.2, 1.05 * np.max(pmf))\n","  pmf_ = np.insert(pmf, 0, pmf[0])\n","  plt.plot(bins, pmf_, drawstyle=\"steps\")\n","  plt.fill_between(bins, pmf_, step=\"pre\", alpha=0.4)\n","  plt.title(f\"Neuron {neuron_idx}\")\n","  plt.xlabel(\"Inter-spike interval (s)\")\n","  plt.ylabel(\"Probability mass\")\n","  plt.xlim(isi_range);\n","  plt.ylim([0, ymax])"]},{"cell_type":"code","execution_count":4,"metadata":{"cellView":"form","colab":{},"colab_type":"code","executionInfo":{"elapsed":2459,"status":"ok","timestamp":1594640299335,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"qH6PbLTnaCBP"},"outputs":[],"source":["#@title Download Data\n","import io\n","import requests\n","r = requests.get('https://osf.io/sy5xt/download')\n","if r.status_code != 200:\n","  print('Could not download data')\n","else:\n","  steinmetz_spikes = np.load(io.BytesIO(r.content), allow_pickle=True)['spike_times']"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"NGVo2zo2cnxX"},"source":["# Section 1: Optimization and Information\n","\n","Neurons can only fire so often in a fixed period of time, as the act of emitting a spike consumes energy that is depleted and must eventually be replenished. To communicate effectively for downstream computation, the neuron would need to make good use of its limited spiking capability. This becomes an optimization problem: \n","\n","What is the optimal way for a neuron to fire in order to maximize its ability to communicate information?\n","\n","In order to explore this question, we first need to have a quantifiable measure for information. Shannon introduced the concept of entropy to do just that, and defined it as\n","\n","\\begin{align}\n","  H_b(X) &= -\\sum_{x\\in X} p(x) \\log_b p(x)\n","\\end{align}\n","\n","where $H$ is entropy measured in units of base $b$ and $p(x)$ is the probability of observing the event $x$ from the set of all possible events in $X$. See the Appendix for a more detailed look at how this equation was derived.\n","\n","The most common base of measuring entropy is $b=2$, so we often talk about *bits* of information, though other bases are used as well e.g. when $b=e$ we call the units *nats*."]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"uFU544W7UDWI"},"source":["First, let's explore how entropy changes between some simple discrete probability distributions. In the rest of this tutorial we will refer to these as probability mass functions (PMF), where $p(x_i)$ equals the $i^{th}$ value in an array, and mass refers to how much of the distribution is contained at that value.\n","\n","For our first PMF, we will choose one where all of the probability mass is located in the middle of the distribution."]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":430},"colab_type":"code","executionInfo":{"elapsed":884,"status":"ok","timestamp":1594640504050,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"9OG6J9jFT7jZ","outputId":"df85b6d8-1287-4173-d633-1f78bdcf7152"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 576x432 with 1 Axes>"]},"metadata":{"image/png":{"height":413,"width":558},"needs_background":"light","tags":[]},"output_type":"display_data"}],"source":["n_bins = 50  # number of points supporting the distribution\n","x_range = (0, 1)  # will be subdivided evenly into bins corresponding to points\n","\n","bins = np.linspace(*x_range, n_bins + 1)  # bin edges\n","\n","pmf = np.zeros(n_bins)\n","pmf[len(pmf) // 2] = 1.0  # middle point has all the mass\n","\n","# Since we already have a PMF, rather than un-binned samples, `plt.hist` is not\n","# suitable. Instead, we directly plot the PMF as a step function to visualize\n","# the histogram:\n","pmf_ = np.insert(pmf, 0, pmf[0])  # this is necessary to align plot steps with bin edges\n","plt.plot(bins, pmf_, drawstyle=\"steps\")\n","# `fill_between` provides area shading\n","plt.fill_between(bins, pmf_, step=\"pre\", alpha=0.4)\n","plt.xlabel(\"x\")\n","plt.ylabel(\"p(x)\")\n","plt.xlim(x_range)\n","plt.ylim(0, 1);"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"UhC2cK3RfFw8"},"source":["If we were to draw a sample from this distribution, we know exactly what we would get every time. Distributions where all the mass is concentrated on a single event are known as *deterministic*.\n","\n","How much entropy is contained in a deterministic distribution?"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"BWQTSVbNhpvb"},"source":["## Exercise 1: Computing Entropy\n","\n","Your first exercise is to implement a method that computes the entropy of a discrete probability distribution, given its mass function. Remember that we are interested in entropy in units of _bits_, so be sure to use the correct log function. \n","\n","Recall that $\\log(0)$ is undefined. When evaluated at $0$, NumPy log functions (such as `np.log2`) return `np.nan` (\"Not a Number\"). By convention, these undefined terms— which correspond to points in the distribution with zero mass—are excluded from the sum that computes the entropy."]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":34},"colab_type":"code","executionInfo":{"elapsed":798,"status":"ok","timestamp":1594640912797,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"pq7rc9_HizOe","outputId":"0921e763-e6f0-41af-c9f6-0625948abd4a"},"outputs":[{"name":"stdout","output_type":"stream","text":["0.00 bits\n"]}],"source":["def entropy(pmf):\n","  \"\"\"Given a discrete distribution, return the Shannon entropy in bits.\n","\n","  This is a measure of information in the distribution. For a totally\n","  deterministic distribution, where samples are always found in the same bin,\n","  then samples from the distribution give no more information and the entropy\n","  is 0.\n","\n","  For now this assumes `pmf` arrives as a well-formed distribution (that is,\n","  `np.sum(pmf)==1` and `not np.any(pmf < 0)`)\n","\n","  Args:\n","    pmf (np.ndarray): The probability mass function for a discrete distribution\n","      represented as an array of probabilities.\n","  Returns:\n","    h (number): The entropy of the distribution in `pmf`.\n","\n","  \"\"\"\n","  ############################################################################\n","  # Exercise for students: compute the entropy of the provided PMF\n","  #   1. Exclude the points in the distribution with no mass (where `pmf==0`).\n","  #      Hint: this is equivalent to including only the points with `pmf>0`.\n","  #   2. Implement the equation for Shannon entropy (in bits).\n","  #  When ready to test, comment or remove the next line\n","  # raise NotImplementedError(\"Excercise: implement the equation for entropy\")\n","  ############################################################################\n","\n","  # reduce to non-zero entries to avoid an error from log2(0)\n","\n","\n","  # implement the equation for Shannon entropy (in bits)\n","\n","\n","  # return the absolute value (avoids getting a -0 result)\n","  return\n","\n","# Uncomment to test your entropy function\n","print(f\"{entropy(pmf):.2f} bits\")"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Solution\n","\n","def entropy(pmf):\n","  \"\"\"Given a discrete distribution, return the Shannon entropy in bits.\n","\n","  This is a measure of information in the distribution. For a totally\n","  deterministic distribution, where samples are always found in the same bin,\n","  then samples from the distribution give no more information and the entropy\n","  is 0.\n","\n","  For now this assumes `pmf` arrives as a well-formed distribution (that is,\n","  `np.sum(pmf)==1` and `not np.any(pmf < 0)`)\n","\n","  Args:\n","    pmf (np.ndarray): The probability mass function for a discrete distribution\n","      represented as an array of probabilities.\n","  Returns:\n","    h (number): The entropy of the distribution in `pmf`.\n","\n","  \"\"\"\n","\n","  # reduce to non-zero entries to avoid an error from log2(0)\n","  pmf = pmf[np.nonzero(pmf)]\n","\n","  # implement the equation for Shannon entropy (in bits)\n","  h = -1 * np.sum(pmf * np.log2(pmf))\n","\n","  # return the absolute value (avoids getting a -0 result)\n","  return np.abs(h)\n","\n","# Uncomment to test your entropy function\n","print(f\"{entropy(pmf):.2f} bits\")"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"nvbN0ndlWzkn"},"source":["We expect zero surprise from a deterministic distribution. If we had done this calculation by hand, it would simply be"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"w8uOSX8OUIEC"},"source":["$-1\\log_2 1 = -0=0$"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"A-T3L9q6jKVp"},"source":["Note that changing the location of the peak (i.e. the point and bin on which all the mass rests) doesn't alter the entropy. The entropy is about how predictable a sample is with respect to a distribution. A single peak is deterministic regardless of which point it sits on."]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":447},"colab_type":"code","executionInfo":{"elapsed":902,"status":"ok","timestamp":1594641247701,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"nJMFWDkBj9qs","outputId":"79d12036-e720-46b1-b427-a5a8c49ad3a6"},"outputs":[{"name":"stdout","output_type":"stream","text":["0.00 bits\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 576x432 with 1 Axes>"]},"metadata":{"image/png":{"height":413,"width":558},"needs_background":"light","tags":[]},"output_type":"display_data"}],"source":["pmf = np.zeros(n_bins)\n","pmf[2] = 1.0  # arbitrary point has all the mass\n","\n","pmf_ = np.insert(pmf, 0, pmf[0])\n","plt.plot(bins, pmf_, drawstyle=\"steps\")\n","plt.fill_between(bins, pmf_, step=\"pre\", alpha=0.4)\n","plt.xlabel(\"x\")\n","plt.ylabel(\"p(x)\")\n","plt.xlim(x_range)\n","plt.ylim(0, 1);\n","print(f\"{entropy(pmf):.2f} bits\")"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"9S-IrwBckNQr"},"source":["What about a distribution with mass split equally between two points?"]},{"cell_type":"code","execution_count":20,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":447},"colab_type":"code","executionInfo":{"elapsed":949,"status":"ok","timestamp":1594641791060,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"l00PLxImjyN-","outputId":"7f60c5df-715c-4d38-992d-50392af0ff22"},"outputs":[{"name":"stdout","output_type":"stream","text":["0.72 bits\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 576x432 with 1 Axes>"]},"metadata":{"image/png":{"height":413,"width":558},"needs_background":"light","tags":[]},"output_type":"display_data"}],"source":["pmf = np.zeros(n_bins)\n","pmf[len(pmf) // 3] = 0.2\n","pmf[2 * len(pmf) // 3] = 0.8\n","\n","pmf_ = np.insert(pmf, 0, pmf[0])\n","plt.plot(bins, pmf_, drawstyle=\"steps\")\n","plt.fill_between(bins, pmf_, step=\"pre\", alpha=0.4)\n","plt.xlabel(\"x\")\n","plt.ylabel(\"p(x)\")\n","plt.xlim(x_range)\n","plt.ylim(0, 1);\n","print(f\"{entropy(pmf):.2f} bits\")"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"X5sxsWO4SVsQ"},"source":["Here, the entropy calculation is"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"sqE-g9o7ljH8"},"source":["$-(0.5 \\log_2 0.5 + 0.5\\log_2 0.5)=1$"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"CBEQZLZkirhN"},"source":["There is 1 bit of entropy. This means that before we take a random sample, there is 1 bit of uncertainty about which point in the distribution the sample will fall on: it will either be the first peak or the second one. \n","\n","Likewise, if we make one of the peaks taller (i.e. its point holds more of the probability mass) and the other one shorter, the entropy will decrease because of the increased certainty that the sample will fall on one point and not the other:\n","\n"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"RpIguql7TN6a"},"source":["$-(0.2 \\log_2 0.2 + 0.8\\log_2 0.8)\\approx 0.72$"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"sgqyjq7qTLXD"},"source":["Try changing the definition of the number and weighting of peaks, and see how the entropy varies."]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"vj8ZuasAS0hi"},"source":["If we split the probability mass among even more points, the entropy continues to increase. Let's derive the general form for $N$ points of equal mass, where $p_i=p=1/N$:\n","\n","\\begin{align}\n"," -\\sum_i p_i \\log_b p_i&= -\\sum_i^N \\frac{1}{N} \\log_b \\frac{1}{N}\\\\\n","                       &= -\\log_b \\frac{1}{N} \\\\\n","                       &= \\log_b N\n","\\end{align}\n","$$$$"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"nBHp_NZEWVKT"},"source":["If we have $N$ discrete points, the _uniform distribution_ (where all points have equal mass) is the distribution with the highest entropy: $\\log_b N$. This upper bound on entropy is useful when considering binning strategies, as any estimate of entropy over $N$ discrete points (or bins) must be in the interval $[0, \\log_b N]$.\n"]},{"cell_type":"code","execution_count":25,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":515},"colab_type":"code","executionInfo":{"elapsed":756,"status":"ok","timestamp":1594642169126,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"behG6ebzasp2","outputId":"4f764912-70a7-4135-fe42-053bd0d8f56b"},"outputs":[{"name":"stdout","output_type":"stream","text":["5.64 bits\n","5.643856189774724\n","5.643856189774724\n","3.32 bits\n","5.643856189774724\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 576x432 with 1 Axes>"]},"metadata":{"image/png":{"height":413,"width":558},"needs_background":"light","tags":[]},"output_type":"display_data"}],"source":["pmf = np.ones(n_bins) / n_bins  # [1/N] * N\n","\n","pmf2 = pmf / 2\n","\n","pmf_ = np.insert(pmf, 0, pmf[0])\n","plt.plot(bins, pmf_, drawstyle=\"steps\")\n","plt.fill_between(bins, pmf_, step=\"pre\", alpha=0.4)\n","plt.xlabel(\"x\")\n","plt.ylabel(\"p(x)\")\n","plt.xlim(x_range);\n","plt.ylim(0, 1);\n","print(f\"{entropy(pmf):.2f} bits\")\n","print(stats.entropy(pmf, base=2))\n","print(np.log2(50))\n","\n","print(f\"{entropy(pmf2):.2f} bits\")\n","print(stats.entropy(pmf2, base=2))"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"gqveX-gKwUXc"},"source":["print(f\"{entropy(pmf):.2f} bits\")\n","print(stats.entropy(pmf, base=2))Here, there are 50 points and the entropy of the uniform distribution is $\\log_2 50\\approx 5.64$. If we construct _any_ discrete distribution $X$ over 50 points (or bins) and calculate an entropy of $H_2(X)>\\log_2 50$, something must be wrong with our implementation of the discrete entropy computation."]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"QH5ZRl5rr7rJ"},"source":["# Section 2: Information, neurons, and spikes"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"iJthWttfbnnk"},"source":["Recall the discussion of spike times and inter-spike intervals (ISIs) from Tutorial 1. What does the information content (or distributional entropy) of these measures say about our theory of nervous systems? \n","\n","We'll consider three hypothetical neurons that all have the same mean ISI, but with different distributions:\n","\n","1. Deterministic\n","2. Uniform\n","3. Exponential\n","\n","Fixing the mean of the ISI distribution is equivalent to fixing its inverse: the neuron's mean firing rate. If a neuron has a fixed energy budget and each of its spikes has the same energy cost, then by fixing the mean firing rate, we are normalizing for energy expenditure. This provides a basis for comparing the entropy of different ISI distributions. In other words: if our neuron has a fixed budget, what ISI distribution should it express (all else being equal) to maximize the information content of its outputs?\n","\n","Let's construct our three distributions and see how their entropies differ."]},{"cell_type":"code","execution_count":26,"metadata":{"colab":{},"colab_type":"code","executionInfo":{"elapsed":433,"status":"ok","timestamp":1594642690954,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"kDtUI-F3FKFf"},"outputs":[],"source":["n_bins = 50\n","mean_isi = 0.025\n","isi_range = (0, 0.25)\n","\n","bins = np.linspace(*isi_range, n_bins + 1)\n","mean_idx = np.searchsorted(bins, mean_isi)\n","\n","# 1. all mass concentrated on the ISI mean\n","pmf_single = np.zeros(n_bins)\n","pmf_single[mean_idx] = 1.0\n","\n","# 2. mass uniformly distributed about the ISI mean\n","pmf_uniform = np.zeros(n_bins)\n","pmf_uniform[0:2*mean_idx] = 1 / (2 * mean_idx)\n","\n","# 3. mass exponentially distributed about the ISI mean\n","pmf_exp = stats.expon.pdf(bins[1:], scale=mean_isi)\n","pmf_exp /= np.sum(pmf_exp)"]},{"cell_type":"code","execution_count":27,"metadata":{"cellView":"form","colab":{"base_uri":"https://localhost:8080/","height":358},"colab_type":"code","executionInfo":{"elapsed":1572,"status":"ok","timestamp":1594642696718,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"mpD1i0Eil4K2","outputId":"6607bf24-d13d-4581-a135-7c6ae2c3c8c4"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1296x360 with 3 Axes>"]},"metadata":{"image/png":{"height":341,"width":1278},"needs_background":"light","tags":[]},"output_type":"display_data"}],"source":["#@title\n","#@markdown Run this cell to plot the three PMFs\n","fig, axes = plt.subplots(ncols=3, figsize=(18, 5))\n","\n","dists =  [# (subplot title, pmf, ylim)\n","          (\"(1) Deterministic\", pmf_single, (0, 1.05)),\n","          (\"(1) Uniform\", pmf_uniform, (0, 1.05)),\n","          (\"(1) Exponential\", pmf_exp, (0, 1.05))]\n","\n","for ax, (label, pmf_, ylim) in zip(axes, dists):\n","  pmf_ = np.insert(pmf_, 0, pmf_[0])\n","  ax.plot(bins, pmf_, drawstyle=\"steps\")\n","  ax.fill_between(bins, pmf_, step=\"pre\", alpha=0.4)\n","  ax.set_title(label)\n","  ax.set_xlabel(\"Inter-spike interval (s)\")\n","  ax.set_ylabel(\"Probability mass\")\n","  ax.set_xlim(isi_range);\n","  ax.set_ylim(ylim);"]},{"cell_type":"code","execution_count":29,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":68},"colab_type":"code","executionInfo":{"elapsed":510,"status":"ok","timestamp":1594642732666,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"foIXzYXFTGTO","outputId":"ccb8ca4d-12ab-41ac-c141-d0233a270421"},"outputs":[{"name":"stdout","output_type":"stream","text":["Deterministic: 0.00 bits\n","Uniform: 3.32 bits\n","Exponential: 3.77 bits\n"]}],"source":["print(\n","  f\"Deterministic: {entropy(pmf_single):.2f} bits\",\n","  f\"Uniform: {entropy(pmf_uniform):.2f} bits\",\n","  f\"Exponential: {entropy(pmf_exp):.2f} bits\",\n","  sep=\"\\n\",\n",")"]},{"cell_type":"code","execution_count":30,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":68},"colab_type":"code","executionInfo":{"elapsed":772,"status":"ok","timestamp":1594642842141,"user":{"displayName":"Evgenii Tretiakov","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Ggu3c2KuDxkCviEiF6RedytMTB3sHW4G95B3lqboQ=s64","userId":"14040943026517255518"},"user_tz":-120},"id":"wPf6BtY-HRN_","outputId":"52bd0325-b57d-4abb-8ea5-53157d693a79"},"outputs":[{"name":"stdout","output_type":"stream","text":["Deterministic: 0.00 bits\n","Uniform: 3.32 bits\n","Exponential: 3.77 bits\n"]}],"source":["print(\n","  f\"Deterministic: {stats.entropy(pmf_single, base=2):.2f} bits\",\n","  f\"Uniform: {stats.entropy(pmf_uniform, base=2):.2f} bits\",\n","  f\"Exponential: {stats.entropy(pmf_exp, base=2):.2f} bits\",\n","  sep=\"\\n\",\n",")"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"Xy5gh59yg2A4"},"source":["In the previous example we created the PMFs by hand to illustrate idealized scenarios. How would we compute them from data recorded from actual neurons?\n","\n","One way is to convert the ISI histograms we've previously computed into discrete probability distributions using the following equation:\n","\n","\\begin{align}\n","p_i = \\frac{n_i}{\\sum\\nolimits_{i}n_i}\n","\\end{align}\n","\n","where $p_i$ is the probability of an ISI falling within a particular interval $i$ and $n_i$ is the count of how many ISIs were observed in that interval."]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"J-Q3nRruGrcr"},"source":["### Exercise 2: Probabilty Mass Function\n","\n","Your second exercise is to implement a method that will produce a probability mass function from an array of ISI bin counts.\n","\n","To verify your solution, we will compute the probability distribution of ISIs from real neural data taken from the Steinmetz dataset."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"is9E9IEeifHs"},"outputs":[],"source":["neuron_idx = 283\n","\n","isi = np.diff(steinmetz_spikes[neuron_idx])\n","bins = np.linspace(*isi_range, n_bins + 1)\n","counts, _ = np.histogram(isi, bins)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{},"colab_type":"code","id":"wxF8I8BafS6Q"},"outputs":[],"source":["def pmf_from_counts(counts):\n","  \"\"\"Given counts, normalize by the total to estimate probabilities.\"\"\"\n","  ###########################################################################\n","  # Exercise: Compute the PMF. Remove the next line to test your function\n","  raise NotImplementedError(\"Student excercise: compute the PMF from ISI counts\")\n","  ###########################################################################\n","\n","  pmf =\n","\n","  return pmf\n","\n","# Uncomment when ready to test your function\n","# pmf = pmf_from_counts(counts)\n","# plot_pmf(pmf,isi_range)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Solution\n","\n","def pmf_from_counts(counts):\n","  \"\"\"Given counts, normalize by the total to estimate probabilities.\"\"\"\n","  pmf = counts / np.sum(counts)\n","  return pmf\n","\n","\n","# Get neuron index\n","neuron_idx = 283\n","\n","# Get counts of ISIs from Steinmetz data\n","isi = np.diff(steinmetz_spikes[neuron_idx])\n","bins = np.linspace(*isi_range, n_bins + 1)\n","counts, _ = np.histogram(isi, bins)\n","\n","# Compute pmf\n","pmf = pmf_from_counts(counts)\n","\n","# Visualize\n","with plt.xkcd():\n","  plot_pmf(pmf, isi_range)"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"KSQDEXkOEvC2"},"source":["# Section 3: Calculate entropy from a PMF"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"W3eU1ZFSPkSY"},"source":["Now that we have the probability distribution for the actual neuron spiking activity, we can calculate its entropy."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":35},"colab_type":"code","id":"yn8ysGHJPxbP","outputId":"da585b68-092e-4de1-9041-bb7ab806e85c"},"outputs":[{"name":"stdout","output_type":"stream","text":["Entropy for Neuron 283: 3.36 bits\n"]}],"source":["print(f\"Entropy for Neuron {neuron_idx}: {entropy(pmf):.2f} bits\")"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"9xWVibPwQZh1"},"source":["## Interactive Demo: Entropy of neurons\n","\n","We can combine the above distribution plot and entropy calculation with an interactive widget to explore how the different neurons in the dataset vary in spiking activity and relative information. Note that the mean firing rate across neurons is not fixed, so some neurons with a uniform ISI distribution may have higher entropy than neurons with a more exponential distribution.\n","\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"cellView":"form","colab":{"base_uri":"https://localhost:8080/","height":462,"referenced_widgets":["2371a383fca2465c848a7530644a94a5","6ee4e3b0704c461b9fddb0d2bd4cb768","65176fdad49d45379a9c9e1238dd4f4e","4c9e02fdedcd42f1ad15f0ae771c9692","d918baf72b2a4b9395346122bcbf817e","fed5ec1c321a44ad92c0ce942f96b9b6","a422984464d44beabb836b92d1d66022"]},"colab_type":"code","id":"nThHQ0skV4ed","outputId":"dc8a4b5c-44a8-4b91-b748-1e6c756fab46"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 576x432 with 1 Axes>"]},"metadata":{"image/png":{"height":413,"width":558},"needs_background":"light","tags":[]},"output_type":"display_data"}],"source":["#@title\n","#@markdown **Run the cell** to enable the sliders.\n","\n","def _pmf_from_counts(counts):\n","  \"\"\"Given counts, normalize by the total to estimate probabilities.\"\"\"\n","  pmf = counts / np.sum(counts)\n","  return pmf\n","\n","def _entropy(pmf):\n","  \"\"\"Given a discrete distribution, return the Shannon entropy in bits.\"\"\"\n","  # remove non-zero entries to avoid an error from log2(0)\n","  pmf = pmf[pmf > 0]\n","  h = -np.sum(pmf * np.log2(pmf))\n","  # absolute value applied to avoid getting a -0 result\n","  return np.abs(h)\n","\n","@widgets.interact(neuron=widgets.IntSlider(0, min=0, max=(len(steinmetz_spikes)-1)))\n","def steinmetz_pmf(neuron):\n","  \"\"\" Given a neuron from the Steinmetz data, compute its PMF and entropy \"\"\"\n","  isi = np.diff(steinmetz_spikes[neuron])\n","  bins = np.linspace(*isi_range, n_bins + 1)\n","  counts, _ = np.histogram(isi, bins)\n","  pmf = _pmf_from_counts(counts)\n","\n","  plot_pmf(pmf,isi_range)\n","  plt.title(f\"Neuron {neuron}: H = {_entropy(pmf):.2f} bits\")\n"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"pPvYtN9ZAdSb"},"source":["---\n","# Summary\n"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"3Deb-YTDJpXX"},"source":["Congratulations! You've finished your first NMA tutorial. In this 3 part tutorial series, we used different types of models to understand the spiking behavior of neurons recorded in the Steinmetz data set. \n","\n"," - We used \"what\" models to discover that the ISI distribution of real neurons is closest to an exponential distribution\n"," - We used \"how\" models to discover that balanced excitatory and inbhitiory inputs, coupled with a leaky membrane, can give rise to neuronal spiking with exhibiting such an exponential ISI distribution\n"," - We used \"why\" models to discover that exponential ISI distributions contain the most information when the mean spiking is constrained\n","\n"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"31qIcbqFeg1m"},"source":["# Bonus"]},{"cell_type":"markdown","metadata":{"colab_type":"text","id":"wqfu7w62TrxX"},"source":["### The foundations for Entropy\n","\n","In his foundational [1948 paper](https://en.wikipedia.org/wiki/A_Mathematical_Theory_of_Communication) on information theory, Claude Shannon began with three criteria for a function $H$ defining the entropy of a discrete distribution of probability masses $p_i\\in p(X)$ over the points $x_i\\in X$:\n","1. $H$ should be continuous in the $p_i$. \n","  - That is, $H$ should change smoothly in response to smooth changes to the mass $p_i$ on each point $x_i$.\n","2. If all the points have equal shares of the probability mass, $p_i=1/N$, $H$ should be a non-decreasing function of $N$. \n","  - That is, if $X_N$ is the support with $N$ discrete points and $p(x\\in X_N)$ assigns constant mass to each point, then $H(X_1) < H(X_2) < H(X_3) < \\dots$\n","3. $H$ should be preserved by (invariant to) the equivalent (de)composition of distributions.\n","  - For example (from Shannon's paper) if we have a discrete distribution over three points with masses $(\\frac{1}{2},\\frac{1}{3},\\frac{1}{6})$, then their entropy can be represented in terms of a direct choice between the three and calculated $H(\\frac{1}{2},\\frac{1}{3},\\frac{1}{6})$. However, it could also be represented in terms of a series of two choices: \n","    1. either we sample the point with mass $1/2$ or not (_not_ is the other $1/2$, whose subdivisions are not given in the first choice), \n","    2. if (with probability $1/2$) we _don't_ sample the first point, we sample one of the two remaining points, masses $1/3$ and $1/6$.\n","    \n","    Thus in this case we require that $H(\\frac{1}{2},\\frac{1}{3},\\frac{1}{6})=H(\\frac{1}{2},\\frac{1}{2}) + \\frac{1}{2}H(\\frac{1}{3}, \\frac{1}{6})$\n","\n","There is a unique function (up to a linear scaling factor) which satisfies these 3 requirements: \n","\n","\\begin{align}\n","  H_b(X) &= -\\sum_{x\\in X} p(x) \\log_b p(x)\n","\\end{align}\n","\n","Where the base of the logarithm $b>1$ controls the units of entropy. The two most common cases are $b=2$ for units of _bits_, and $b=e$ for _nats_.\n","\n","We can view this function as the expectation of the self-information over a distribution:\n","\n","$$H_b(X) = \\mathbb{E}_{x\\in X} \\left[I_b(x)\\right]$$\n","\n","$$I_b(x)=-\\log_b p(x)$$\n","\n","Self-information is just the negative logarithm of probability, and is a measure of how surprising an event sampled from the distribution would be. Events with $p(x)=1$ are certain to occur, and their self-information is zero (as is the entropy of the distribution they compose) meaning they are totally unsurprising. The smaller the probability of an event, the higher its self-information, and the more surprising the event would be to observe. \n"]}],"metadata":{"colab":{"collapsed_sections":[],"name":"Copy of NeuromatchAcademy_W1D1_Tutorial3","provenance":[{"file_id":"https://github.com/NeuromatchAcademy/course-content/blob/master/tutorials/W1D1_ModelTypes/student/W1D1_Tutorial3.ipynb","timestamp":1594640273226}],"toc_visible":true},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.7"}},"nbformat":4,"nbformat_minor":0}