03_workshop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scale-Free Networks\n",
    "\n",
    "Code examples from [Think Complexity, 2nd edition](https://thinkcomplex.com).\n",
    "\n",
    "Copyright 2016 Allen Downey, [MIT License](http://opensource.org/licenses/MIT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If we're running on Colab, install empiricaldist\n",
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !pip install empiricaldist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from empiricaldist import Pmf, Cdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorate(**options):\n",
    "    plt.gca().set(**options)\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from warnings import simplefilter\n",
    "#from matplotlib.cbook import mplDeprecation\n",
    "#simplefilter('ignore', mplDeprecation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To represent social networks, we'll use `nx.Graph`, the graph representation provided by NetworkX.\n",
    "\n",
    "Each person is represented by a node.  Each friendship is represented by an edge between two nodes.\n",
    "\n",
    "Here's a simple example with 4 people:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.Graph()\n",
    "G.add_edge(1, 0)\n",
    "G.add_edge(2, 0)\n",
    "G.add_edge(3, 0)\n",
    "nx.draw(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of friends a person has is the number of edges that connect to their node, which is the \"degree\" of the node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for node in G.nodes():\n",
    "    print(node, G.degree(node))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are often intereted in the \"degree distribution\" of a graph, which is the number of people who have 0 friends, the number who have 1 friend, and so on.\n",
    "\n",
    "The following function extracts a list of degrees, one for each node in a graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def degrees(G):\n",
    "    \"\"\"List of degrees for nodes in `G`.\n",
    "    \n",
    "    G: Graph object\n",
    "    \n",
    "    returns: list of int\n",
    "    \"\"\"\n",
    "    return [G.degree(node) for node in G]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the result for the small example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "degrees(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll use `Pmf` from `empiricaldist` to make a probability mass function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf = Pmf.from_seq(degrees(G))\n",
    "pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And `bar` to display it as a bar plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pmf.bar()\n",
    "decorate(xlabel='Degree', ylabel='PMF', xlim=[0.4, 3.6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Add another node or nodes to the graph above, and add a few edges.  Plot the new degree distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Facebook data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function reads a file with one edge per line, specified by two integer node IDs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_graph(filename):\n",
    "    \"\"\"Read a graph from a file.\n",
    "    \n",
    "    filename: string\n",
    "    \n",
    "    return: Graph\n",
    "    \"\"\"\n",
    "    G = nx.Graph()\n",
    "    array = np.loadtxt(filename, dtype=int)\n",
    "    G.add_edges_from(array)\n",
    "    return G"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll read the Facecook data downloaded from [SNAP](https://snap.stanford.edu/data/egonets-Facebook.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print('Downloaded ' + local)\n",
    "        \n",
    "download('https://github.com/AllenDowney/ComplexityScience/raw/master/facebook_combined.txt.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://snap.stanford.edu/data/facebook_combined.txt.gz\n",
    "\n",
    "fb = read_graph('facebook_combined.txt.gz')\n",
    "n = len(fb)\n",
    "m = len(fb.edges())\n",
    "n, m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see how popular \"you\" are, on average, we'll draw a random sample of 1000 people."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample = np.random.choice(fb.nodes(), 1000, replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each \"you\" in the sample, we'll look up the number of friends."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_friends = [fb.degree(node) for node in sample]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To plot the degree distribution, I'll use `EstimatedPdf`, which computes a smooth Probability Density Function that fits the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pmf.from_seq(sample_friends).plot()\n",
    "decorate(xlabel='Number of friends', \n",
    "         ylabel='PMF',\n",
    "         title='Degree PMF, friends')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "Cdf.from_seq(sample_friends).plot(color='C0')\n",
    "decorate(xlabel='Number of friends', \n",
    "         ylabel='CDF',\n",
    "         title='Degree CDF, friends')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now what if, instead of \"you\", we choose one of your friends, and look up the number of friends your friend has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_fof = []\n",
    "for node in sample:\n",
    "    friends = list(fb.neighbors(node))\n",
    "    friend = np.random.choice(friends)\n",
    "    sample_fof.append(fb.degree(friend))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the degree distribution for your friend's friends:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pmf.from_seq(sample_fof).plot()\n",
    "decorate(xlabel='Number of friends', \n",
    "         ylabel='PMF',\n",
    "         title='Degree PMF, friends of friends')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "Cdf.from_seq(sample_fof).plot(color='C1')\n",
    "decorate(xlabel='Number of friends', \n",
    "         ylabel='CDF',\n",
    "         title='Degree CDF, friends of friends')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "Cdf.from_seq(sample_friends).plot(color='C0', label='friends')\n",
    "Cdf.from_seq(sample_fof).plot(color='C1', label='friends of friends')\n",
    "decorate(xlabel='Number of friends', \n",
    "         ylabel='CDF',\n",
    "         title='Degree distributions')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bulk of the distribution is wider, and the tail is thicker.  This difference is reflected in the means:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(sample_friends), np.mean(sample_fof)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can estimate the probability that your friend has more friends than you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean([friend > you for you, friend in zip(sample_friends, sample_fof)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Power law distributions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we'll see below, the degree distribution in the Facebook data looks, in some ways, like a power law distribution.  To see what that means, we'll look at the Zipf distribution, which has a power law tail.\n",
    "\n",
    "Here's a sample from a Zipf distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "zipf_sample = np.random.zipf(a=2, size=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what the PMF looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf = Pmf.from_seq(zipf_sample)\n",
    "pmf.plot()\n",
    "decorate(xlabel='Zipf sample', ylabel='PMF')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here it is on a log-x scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf.plot()\n",
    "decorate(xlabel='Zipf sample (log)', ylabel='PMF', xscale='log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And on a log-log scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf.plot()\n",
    "decorate(xlabel='Zipf sample (log)', ylabel='PMF (log)', \n",
    "                 xscale='log', yscale='log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a log-log scale, the PMF of the Zipf distribution looks like a straight line (until you get to the extreme tail, which is discrete and noisy)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For comparison, let's look at the Poisson distribution, which does not have a power law tail.  I'll choose the Poisson distribution with the same mean as the sample from the Zipf distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu, sigma = zipf_sample.mean(), zipf_sample.std()\n",
    "mu, sigma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "poisson_sample = np.random.poisson(lam=mu, size=10000)\n",
    "poisson_sample.mean(), poisson_sample.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the PMF on a log-log scale.  It is definitely not a straight line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "poisson_pmf = Pmf.from_seq(poisson_sample)\n",
    "poisson_pmf.plot()\n",
    "decorate(xlabel='Poisson sample (log)', ylabel='PMF (log)', \n",
    "                 xscale='log', yscale='log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So this gives us a simple way to test for power laws.  If you plot the PMF on a log-log scale, and the result is a straight line, they is evidence of power law behavior.\n",
    "\n",
    "This test is not entirely reliable; there are better options.  But it's good enough for an initial exploration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Barabási and Albert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what the degree distribution for the Facebook data looks like on a log-log scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf_fb = Pmf.from_seq(degrees(fb))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf_fb.plot(label='Facebook')\n",
    "decorate(xscale='log', \n",
    "         yscale='log',\n",
    "         xlabel='Degree (log)', \n",
    "         ylabel='PMF (log)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For degrees greater than 10, it resembles the Zipf sample (and doesn't look much like the Poisson sample).\n",
    "\n",
    "We can estimate the parameter of the Zipf distribution by eyeballing the slope of the tail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([10, 1000], [5e-2, 2e-4], color='gray', linestyle='dashed')\n",
    "\n",
    "pmf_fb.plot(label='Facebook')\n",
    "decorate(xscale='log', \n",
    "         yscale='log',\n",
    "         xlabel='Degree (log)', \n",
    "         ylabel='PMF (log)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simplified version of the NetworkX function that generates BA graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# modified version of the NetworkX implementation from\n",
    "# https://github.com/networkx/networkx/blob/master/networkx/generators/random_graphs.py\n",
    "\n",
    "import random\n",
    "\n",
    "def barabasi_albert_graph(n, k, seed=None):\n",
    "    \"\"\"Constructs a BA graph.\n",
    "    \n",
    "    n: number of nodes\n",
    "    k: number of edges for each new node\n",
    "    seed: random seen\n",
    "    \"\"\"\n",
    "    if seed is not None:\n",
    "        random.seed(seed)\n",
    "    \n",
    "    G = nx.empty_graph(k)\n",
    "    targets = set(range(k))\n",
    "    repeated_nodes = []\n",
    "\n",
    "    for source in range(k, n):\n",
    "\n",
    "        G.add_edges_from(zip([source]*k, targets))\n",
    "\n",
    "        repeated_nodes.extend(targets)\n",
    "        repeated_nodes.extend([source] * k)\n",
    "\n",
    "        targets = _random_subset(repeated_nodes, k)\n",
    "\n",
    "    return G"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's the function that generates a random subset without repetition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _random_subset(repeated_nodes, k):\n",
    "    \"\"\"Select a random subset of nodes without repeating.\n",
    "    \n",
    "    repeated_nodes: list of nodes\n",
    "    k: size of set\n",
    "    \n",
    "    returns: set of nodes\n",
    "    \"\"\"\n",
    "    targets = set()\n",
    "    while len(targets) < k:\n",
    "        x = random.choice(repeated_nodes)\n",
    "        targets.add(x)\n",
    "    return targets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll generate a BA graph with the same number of nodes and edges as the Facebook data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = len(fb)\n",
    "m = len(fb.edges())\n",
    "k = int(round(m/n))\n",
    "n, m, k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Providing a random seed means we'll get the same graph every time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "ba = barabasi_albert_graph(n, k, seed=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of edges is pretty close to what we asked for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(ba), len(ba.edges()), len(ba.edges())/len(ba)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the mean degree is about right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(degrees(fb)), np.mean(degrees(ba))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard deviation of degree is pretty close; maybe a little low."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(degrees(fb)), np.std(degrees(ba))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the degree distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf_ba = Pmf.from_seq(degrees(ba))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the PMFs on a linear scale, we see one difference, which is that the BA model has no nodes with degree less than `k`, which is 22."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,6))\n",
    "plt.subplot(1, 2, 1)\n",
    "\n",
    "pmf_fb.plot(label='Facebook')\n",
    "decorate(xlabel='Degree', ylabel='PMF')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "\n",
    "pmf_ba.plot(label='BA model')\n",
    "decorate(xlabel='Degree', ylabel='PMF')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we look at the PMF on a log-log scale, the BA model looks pretty good for values bigger than about 20.  And it seems to follow a power law."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,6))\n",
    "plt.subplot(1, 2, 1)\n",
    "\n",
    "pmf_fb.plot(label='Facebook')\n",
    "decorate(xlabel='Degree', ylabel='PMF',\n",
    "         xscale='log', yscale='log')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "\n",
    "pmf_ba.plot(label='BA model')\n",
    "decorate(xlabel='Degree', ylabel='PMF',\n",
    "         xlim=[1, 1e4],\n",
    "         xscale='log', yscale='log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cumulative distributions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the degree CDFs for the Facebook data, the WS model, and the BA model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "cdf_fb = Cdf.from_seq(degrees(fb))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "cdf_ba = Cdf.from_seq(degrees(ba))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we plot them on a log-x scale, we get a sense of how well the model fits the central part of the distribution.\n",
    "\n",
    "The BA model is ok for values above the median, but not very good for smaller values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "cdf_fb.plot(label='Facebook')\n",
    "cdf_ba.plot(color='gray', label='BA model')\n",
    "decorate(xlabel='Degree', xscale='log',\n",
    "                 ylabel='CDF')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we plot the complementary CDF on a log-log scale, we see that the BA model fits the tail of the distribution reasonably well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "complementary_cdf_fb = 1-cdf_fb\n",
    "complementary_cdf_ba = 1-cdf_ba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "complementary_cdf_fb.plot(label='Facebook')\n",
    "complementary_cdf_ba.plot(color='gray', label='BA model')\n",
    "decorate(xlabel='Degree', xscale='log',\n",
    "         ylabel='Complementary CDF', yscale='log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there is certainly room for a model that does a better job of fitting the whole distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}