probability examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A random assortment of statistics and probability examples\n",
    "__1. Birthday paradox__\n",
    "<br>__2. Coupon collector's problem__\n",
    "<br>__3. Poisson and exponential events probabilities__\n",
    "<br>__4. Goodness of fit: chi-squared and k-s tests__\n",
    "<br>__5. Jeep problem__\n",
    "<br>__6. Streaks__\n",
    "<br>__7. Imperfect Streaks__\n",
    "<br>__8. Simulated Chinese Restaurant Process__\n",
    "<br>__9. Simulated Dirichlet Process__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.stats\n",
    "import scipy.optimize\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Birthday paradox\n",
    "Probability of having the same birthday.\n",
    "<br>Some cool algebra tricks wth help of Taylor expansion of exp(x)\n",
    "<br>https://betterexplained.com/articles/understanding-the-birthday-paradox/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.04811882531956668"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Probability given number people in room\n",
    "days_in_year: int = 365\n",
    "people_in_room: int = 6\n",
    "\n",
    "prob_different = np.exp(-1*(people_in_room ** 2 / (2 * days_in_year)))\n",
    "prob_same = 1 - prob_different\n",
    "prob_same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.00167213523923"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### How many people to get certain probability\n",
    "desired_prob_same = 0.9\n",
    "\n",
    "prob_different = 1 - desired_prob_same\n",
    "# 0 = people_in_room^2 - people_in_room + 2 * days_in_year * np.ln(prob_different)\n",
    "people_in_room = 1 + np.sqrt(1**2 - 4 * 1 * 2 * days_in_year * np.log(prob_different)) / (2 * 1)\n",
    "people_in_room"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Coupon collector's problem\n",
    "Approach: work back from probabilities of getting the next unpossessed coupon.\n",
    "<br>(Number of coupons required is reciprocal to probability of getting needed coupons.)\n",
    "<br>Thanks to algebra, the summation simplifies to a quantity including the harmonic number of coupons.\n",
    "<br>https://brilliant.org/wiki/coupon-collector-problem/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29.29"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number_coupons: int = 10\n",
    "\n",
    "def harmonic_num(x: int):\n",
    "    harmonic_number: float = 0.0\n",
    "    for i in range(x):\n",
    "        harmonic_number += 1/(i + 1)\n",
    "    return harmonic_number\n",
    "number_times: float = number_coupons * harmonic_num(number_coupons)\n",
    "np.round(number_times, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Poisson events and exponential time between events\n",
    "<br>References: Wiki articles for poisson and exponential distributions\n",
    "<br>https://stats.stackexchange.com/questions/2092/relationship-between-poisson-and-exponential-distribution\n",
    "\n",
    "__Baseball no-hitters events__\n",
    "<br>[sandcat.middlebury.edu/econ/repec/mdl/ancoec/0717.pdf](sandcat.middlebury.edu/econ/repec/mdl/ancoec/0717.pdf)\n",
    "<br>49 no-hitters in 40 years 1920-1959; over 280 months of baseball season\n",
    "<br>lambda = 1.225 no-hitters per year\n",
    "<br>lambda = 0.175 no-hitters per month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg number events per time period: 0.175\n",
      "Number of events in that time period to investigate: 0\n",
      "Prob_of_that_number_of_events: 0.839\n",
      "Prob_of_that_number_or_fewer_events (including 0): 0.839\n"
     ]
    }
   ],
   "source": [
    "avg_event_rate = 49/280 # lambda: the number occurences per time period\n",
    "\n",
    "### Poisson: probability of a given number of events occuring\n",
    "number_events_per_time_interval_to_investigate: int = 0\n",
    "    \n",
    "def poisson_pdf(rate, number_events_to_check):\n",
    "    return (rate ** number_events_to_check * \n",
    "            np.exp(-1 * rate) /\n",
    "            np.math.factorial(number_events_to_check))\n",
    "    \n",
    "prob_of_that_number_of_events = poisson_pdf(rate = avg_event_rate, \n",
    "                                            number_events_to_check = number_events_per_time_interval_to_investigate)\n",
    "\n",
    "prob_of_that_number_or_fewer_events = 0\n",
    "for i in range(number_events_per_time_interval_to_investigate + 1):\n",
    "    prob_of_that_number_or_fewer_events += \\\n",
    "    poisson_pdf(rate = avg_event_rate, \n",
    "                number_events_to_check = i)\n",
    "\n",
    "print(\"Avg number events per time period:\", \n",
    "      np.round(avg_event_rate, 3))\n",
    "print(\"Number of events in that time period to investigate:\", number_events_per_time_interval_to_investigate)\n",
    "print(\"Prob_of_that_number_of_events:\", \n",
    "      np.round(prob_of_that_number_of_events, 3))\n",
    "print(\"Prob_of_that_number_or_fewer_events (including 0):\", \n",
    "      np.round(prob_of_that_number_or_fewer_events, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg number events per time period: 0.175\n",
      "Time between events to investigate: 0.143\n",
      "Prob_of_that_time_or_less_between_events (including 0): 0.025\n",
      "Avg_time_between_events: 5.714\n",
      "Probability of avg time or less between events: 0.632\n",
      "Median_time_between_events 3.961\n"
     ]
    }
   ],
   "source": [
    "avg_event_rate = 49/280 # lambda: the number occurences per time period\n",
    "\n",
    "### Exponential: time between events\n",
    "time_to_investigate = 1/7 # 7 months in mlb season\n",
    "\n",
    "prob_of_that_exact_time_between_occurences = avg_event_rate * np.exp(-1 * avg_event_rate * time_to_investigate)\n",
    "prob_of_time_between_occurences = 1 - np.exp(-1 * avg_event_rate * time_to_investigate) # this amount of time or less\n",
    "\n",
    "avg_time_between_events = 1 / avg_event_rate\n",
    "median_time_between_events = np.log(2) / avg_event_rate\n",
    "median_time_between_events\n",
    "\n",
    "print(\"Avg number events per time period:\", \n",
    "      np.round(avg_event_rate, 3))\n",
    "print(\"Time between events to investigate:\", \n",
    "      np.round(time_to_investigate, 3))\n",
    "# print(\"Prob_density_at_that_exact_time_between_occurences:\", \n",
    "#       np.round(prob_of_that_exact_time_between_occurences, 3))\n",
    "print(\"Prob_of_that_time_or_less_between_events (including 0):\", \n",
    "      np.round(prob_of_time_between_occurences, 3))\n",
    "print(\"Avg_time_between_events:\", \n",
    "      np.round(avg_time_between_events, 3))\n",
    "print(\"Probability of avg time or less between events:\", \n",
    "      np.round(1 - np.exp(-1 * avg_event_rate * avg_time_between_events), 3))\n",
    "print(\"Median_time_between_events\", \n",
    "      np.round(median_time_between_events, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Goodness of fit\n",
    "Chi-squared test for deviation from expected distribution\n",
    "<br>Only for binned/categorical data\n",
    "<br>[sandcat.middlebury.edu/econ/repec/mdl/ancoec/0717.pdf](sandcat.middlebury.edu/econ/repec/mdl/ancoec/0717.pdf)\n",
    "<br>https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chisquare.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If pvalue below 0.05, observations do not belong to expected distribution.\n",
      "P-value = 0.9878024170265235\n"
     ]
    }
   ],
   "source": [
    "observed_array = [11, 15, 9, 4, 1]\n",
    "expected_array = [11.75, 14.39, 8.8164, 3.6, 1.1025]\n",
    "dof_adjustment = 1 # +1 if also estimating mean for poisson from sample data\n",
    "\n",
    "print(\"If pvalue below 0.05, observations do not belong to expected distribution.\")\n",
    "print(\"P-value =\",\n",
    "      scipy.stats.chisquare(f_obs = observed_array,\n",
    "                            f_exp = expected_array,\n",
    "                            ddof = dof_adjustment)[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Goodness of fit for continuous variables\n",
    "<br>https://stats.stackexchange.com/questions/76350/goodness-of-fit-for-continuous-variables\n",
    "\n",
    "Scipy kstest\n",
    "<br>https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kstest.html\n",
    "\n",
    "List of continuous distributions in scipy\n",
    "<br>https://docs.scipy.org/doc/scipy/reference/stats.html#module-scipy.stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KstestResult(statistic=0.5000427891604897, pvalue=9.655302994802462e-232)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scipy.stats.kstest(rvs = scipy.stats.uniform.rvs(size=1000, random_state = 12345),\n",
    "                  cdf = \"norm\",\n",
    "                  #args = (1, 1),\n",
    "                   # N = 20,\n",
    "                  alternative = 'two-sided',\n",
    "                  mode = 'approx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Named tuple\n",
    "<br>https://docs.python.org/2/library/collections.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "norm_args = collections.namedtuple('norm_args', ['loc', 'scale'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KstestResult(statistic=0.02526609656624318, pvalue=0.5457961444206735)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scipy.stats.kstest(rvs = scipy.stats.norm.rvs(loc = 1,\n",
    "                                              scale = 1,\n",
    "                                              size = 1000, \n",
    "                                              random_state = 12345),\n",
    "                  cdf = \"norm\",\n",
    "                  args = norm_args(loc=1, scale=1),\n",
    "                   # N = 20,\n",
    "                  alternative = 'two-sided',\n",
    "                  mode = 'approx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "uniform_args = collections.namedtuple('uniform_args', ['loc', 'scale'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KstestResult(statistic=0.014856419814211264, pvalue=0.9800639362901664)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scipy.stats.kstest(rvs = scipy.stats.uniform.rvs(loc = 1,\n",
    "                                                 scale = 1,\n",
    "                                                 size=1000, \n",
    "                                                 random_state = 12345),\n",
    "                  cdf = \"uniform\",\n",
    "                  args = uniform_args(loc=1, scale=1),\n",
    "                   # N = 20,\n",
    "                  alternative = 'two-sided',\n",
    "                  mode = 'approx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Jeep problem\n",
    "<br>https://en.wikipedia.org/wiki/Jeep_problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12367 trips needed to explore\n",
      "3092 trips needed to cross\n"
     ]
    }
   ],
   "source": [
    "desert_width = 5\n",
    "\n",
    "def dist_explore(num_trips):\n",
    "    return harmonic_num(x = num_trips) / 2\n",
    "\n",
    "def dist_cross(num_trips):\n",
    "    final_trip_distance = 0.0\n",
    "    for i in range(num_trips):\n",
    "        final_trip_distance += 1 / (2 * (i + 1) - 1)\n",
    "    return final_trip_distance\n",
    "\n",
    "resultant_distance = 0.0\n",
    "n_trips_to_explore = 0\n",
    "while resultant_distance < desert_width:\n",
    "    n_trips_to_explore += 1\n",
    "    resultant_distance = dist_explore(num_trips = n_trips_to_explore)\n",
    "\n",
    "resultant_distance = 0.0\n",
    "n_trips_to_cross = 0\n",
    "while resultant_distance < desert_width:\n",
    "    n_trips_to_cross += 1\n",
    "    resultant_distance = dist_cross(num_trips = n_trips_to_cross)\n",
    "\n",
    "print(n_trips_to_explore, \"trips needed to explore\")\n",
    "print(n_trips_to_cross, \"trips needed to cross\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Streaks\n",
    "What's the probability of a given success or fail streak?\n",
    "<br>(This is a nice problem to introduce Markov Chains, but the chain is slower to compute.)\n",
    "<br>https://www.askamathematician.com/2010/07/q-whats-the-chance-of-getting-a-run-of-k-successes-in-n-bernoulli-trials-why-use-approximations-when-the-exact-answer-is-known/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.setrecursionlimit(20000)\n",
    "\n",
    "def prob_of_streak(num_trials, streak_length, prob_success, saved = None):\n",
    "    if saved == None: saved = {}\n",
    "    \n",
    "    ID = (num_trials, streak_length, prob_success)\n",
    "    \n",
    "    if ID in saved: return saved[ID]\n",
    "    else:\n",
    "        if streak_length > num_trials or num_trials <= 0:\n",
    "            result = 0\n",
    "        else:\n",
    "            result = prob_success ** streak_length\n",
    "            for first_fail in range(1, streak_length + 1):\n",
    "                pr = prob_of_streak(num_trials = num_trials - first_fail,\n",
    "                                   streak_length = streak_length,\n",
    "                                   prob_success = prob_success,\n",
    "                                   saved = saved)\n",
    "                result += (prob_success ** (first_fail - 1)) * (1 - prob_success) * pr\n",
    "        saved[ID] = result\n",
    "        \n",
    "        return result    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test function with single iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.407870509145775e-297"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_success = 0.350 # -.350 on base %\n",
    "n_trials = 650    # plate appearances per year\n",
    "\n",
    "prob_of_streak(num_trials = n_trials, \n",
    "               streak_length = 650, \n",
    "               prob_success = p_success)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prob_streak_list(prob_success, n_trials):\n",
    "    probs_success_streak = [prob_of_streak(num_trials = n_trials, \n",
    "                                       streak_length = 1,\n",
    "                                       prob_success = prob_success)]\n",
    "\n",
    "    i = 2\n",
    "    while i <= n_trials:\n",
    "        if probs_success_streak[i - 2] <= 0.0001:\n",
    "            probs_success_streak.append(0.0)\n",
    "            i += 1\n",
    "        elif probs_success_streak[i - 2] >= 0.999:\n",
    "            tmp = prob_of_streak(num_trials = n_trials, \n",
    "                                 streak_length = i + 1,\n",
    "                                 prob_success = prob_success)\n",
    "            if tmp >= 0.999:\n",
    "                probs_success_streak.append((probs_success_streak[i - 2] + tmp) /2)\n",
    "                probs_success_streak.append(tmp)\n",
    "                i += 2\n",
    "            else:\n",
    "                probs_success_streak.append(prob_of_streak(num_trials = n_trials, \n",
    "                                                       streak_length = i,\n",
    "                                                       prob_success = prob_success))\n",
    "                probs_success_streak.append(tmp)\n",
    "                i += 2\n",
    "        else:\n",
    "            probs_success_streak.append(prob_of_streak(num_trials = n_trials, \n",
    "                                                   streak_length = i,\n",
    "                                                   prob_success = prob_success))\n",
    "            i += 1\n",
    "    return [x for x in probs_success_streak if x > 0]\n",
    "\n",
    "def prob_streak_lists(prob_success, n_trials):\n",
    "    return [prob_streak_list(prob_success_i, n_trials) for prob_success_i in [prob_success, 1 - prob_success]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Baseball hits example__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_success = 0.350 # 0.350 on base %\n",
    "num_trials =  650    # plate appearances per year\n",
    "streak_list_results = prob_streak_lists(prob_success =  p_success,\n",
    "                                        n_trials = num_trials)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(len(streak_list_results[0]))], streak_list_results[0],\n",
    "               label = 'Success',\n",
    "               linestyle = '-', color = 'green')\n",
    "plt.plot([i for i in range(len(streak_list_results[1]))], streak_list_results[1],\n",
    "               label = 'Unsuccess',\n",
    "               linestyle = '', marker = '.', color = 'red')\n",
    "plt.xlabel('Streak Length')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('Probability of Streak Lengths for ' + str(p_success) + \" Chance of Success and \" +\n",
    "         str(num_trials) + \" Trials\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check slump results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0,\n",
       " 0.9999999999999998,\n",
       " 0.9999999999999996,\n",
       " 0.999999999999999,\n",
       " 0.9999999999999984,\n",
       " 0.9999986946518137,\n",
       " 0.9999973893036289,\n",
       " 0.9996594807180735,\n",
       " 0.9934220579691067,\n",
       " 0.9588218921219284,\n",
       " 0.8697568870122705,\n",
       " 0.7297720428653122,\n",
       " 0.569449053814327,\n",
       " 0.4195509348521937]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streak_list_results[1][0:14]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even an exceptional hitter should expect 8-9 in-a-row slump during the season.\n",
    "\n",
    "But if a batter is in a 14-straight slump with a season average of 0.350, they probably are actually in a slump."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Basketball shots example__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "p_success = 0.53 # 53% field goal percentage\n",
    "num_trials =  15 * 82 # 15 field goals attempted per game, 82 games per season \n",
    "streak_list_results = prob_streak_lists(prob_success =  p_success,\n",
    "                                        n_trials = num_trials)\n",
    "\n",
    "plt.plot([i for i in range(len(streak_list_results[0]))], streak_list_results[0],\n",
    "               label = 'Success',\n",
    "               linestyle = '-', color = 'green')\n",
    "plt.plot([i for i in range(len(streak_list_results[1]))], streak_list_results[1],\n",
    "               label = 'Unsuccess',\n",
    "               linestyle = '', marker = '.', color = 'red')\n",
    "plt.xlabel('Streak Length')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('Probability of Streak Lengths for ' + str(p_success) + \" Chance of Success and \" +\n",
    "         str(num_trials) + \" Trials\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0,\n",
       " 0.9999999999999996,\n",
       " 0.9999999999999992,\n",
       " 0.9999999999992637,\n",
       " 0.9999999999985283,\n",
       " 0.9995714941544882,\n",
       " 0.999142988310448,\n",
       " 0.9746329050304372,\n",
       " 0.8541837388875277,\n",
       " 0.6369811014505753,\n",
       " 0.41412608868743445,\n",
       " 0.24612583888598696,\n",
       " 0.13880432660110342,\n",
       " 0.07603274776428774,\n",
       " 0.04099623343587418]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streak_list_results[0][0:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, a player who shoots 53% from the field career, should have a 10 shot streak in 64% of seasons.\n",
    "<br>If they don't, then their accuracy was changing season to season.\n",
    "\n",
    "Another way, if they shot 53% for the season but had a 15 shot streak, their accuracy inconsistent through the season."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Steph curry's 100 4th quarter free throws in a row__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "p_success = 0.934 # 0.906 career, 0.934 season best\n",
    "num_trials = 7 * 82 / 4 # free throw attempts per game, games per season, 1/4 for 4th quarter only\n",
    "streak_list_results = prob_streak_lists(prob_success =  p_success,\n",
    "                                        n_trials = num_trials)\n",
    "plt.plot([i for i in range(len(streak_list_results[0]))], streak_list_results[0],\n",
    "               label = 'Success',\n",
    "               linestyle = '-', color = 'green')\n",
    "plt.plot([i for i in range(len(streak_list_results[1]))], streak_list_results[1],\n",
    "               label = 'Unsuccess',\n",
    "               linestyle = '', marker = '.', color = 'red')\n",
    "plt.xlabel('Streak Length')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('Probability of Streak Lengths for ' + str(p_success) + \" Chance of Success and \" +\n",
    "         str(num_trials) + \" Trials\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Overall Freethrow Accuracy</th>\n",
       "      <th>Probability of seeing 100-streak 4th Quarter in a season</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.968993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20.0</td>\n",
       "      <td>0.977370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>0.982507</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40.0</td>\n",
       "      <td>0.986299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.989357</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60.0</td>\n",
       "      <td>0.991953</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>70.0</td>\n",
       "      <td>0.994236</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>80.0</td>\n",
       "      <td>0.996299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>90.0</td>\n",
       "      <td>0.998204</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Overall Freethrow Accuracy  \\\n",
       "0                       10.0   \n",
       "1                       20.0   \n",
       "2                       30.0   \n",
       "3                       40.0   \n",
       "4                       50.0   \n",
       "5                       60.0   \n",
       "6                       70.0   \n",
       "7                       80.0   \n",
       "8                       90.0   \n",
       "\n",
       "   Probability of seeing 100-streak 4th Quarter in a season  \n",
       "0                                           0.968993         \n",
       "1                                           0.977370         \n",
       "2                                           0.982507         \n",
       "3                                           0.986299         \n",
       "4                                           0.989357         \n",
       "5                                           0.991953         \n",
       "6                                           0.994236         \n",
       "7                                           0.996299         \n",
       "8                                           0.998204         "
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_success = 0.934 # 0.906 career, 0.934 season best\n",
    "num_trials = 7 * 82 / 4 # free throw attempts per game, games per season, 1/4 for 4th quarter only\n",
    "\n",
    "def optim_100_shots(p_success, num_trials, streak_length, target_prob):\n",
    "    return (prob_of_streak(num_trials, streak_length, prob_success = p_success, saved = None) -\n",
    "           target_prob) ** 2 \n",
    "    \n",
    "#scipy.optimize.minimize_scalar(optim_100_shots, bounds = (0.001, 0.999), method='bounded', \n",
    "#                               args = (num_trials, 100, 0.1), options={'xatol': 1e-05, 'maxiter': 500, 'disp': 1})\n",
    "\n",
    "target_probs = np.arange(0.1, 1.0, 0.1)\n",
    "pd.DataFrame({\"Overall Freethrow Accuracy\" : [str(np.round(target_prob * 100)) for target_prob in target_probs],\n",
    "            \"Probability of seeing 100-streak 4th Quarter in a season\" : \n",
    "              [scipy.optimize.minimize_scalar(optim_100_shots, bounds = (0.001, 0.999), method='bounded', \n",
    "                                args = (num_trials, 100, target_prob))['x'] \n",
    "             for target_prob in target_probs]})\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aside from cherry-picking the 4th quarter stats, Steph was legitimately playing better than his own high free throw % average during the 4th quarter of games during his streak.\n",
    "\n",
    "__What about karl malone's 18 straight free-throws in a finals game?__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Overall Freethrow Accuracy</th>\n",
       "      <th>Probability of seeing 100-streak 4th Quarter in a season</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.732645</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20.0</td>\n",
       "      <td>0.769017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>0.792988</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40.0</td>\n",
       "      <td>0.811997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50.0</td>\n",
       "      <td>0.828573</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60.0</td>\n",
       "      <td>0.844046</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>70.0</td>\n",
       "      <td>0.859433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>80.0</td>\n",
       "      <td>0.875987</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>90.0</td>\n",
       "      <td>0.896521</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Overall Freethrow Accuracy  \\\n",
       "0                       10.0   \n",
       "1                       20.0   \n",
       "2                       30.0   \n",
       "3                       40.0   \n",
       "4                       50.0   \n",
       "5                       60.0   \n",
       "6                       70.0   \n",
       "7                       80.0   \n",
       "8                       90.0   \n",
       "\n",
       "   Probability of seeing 100-streak 4th Quarter in a season  \n",
       "0                                           0.732645         \n",
       "1                                           0.769017         \n",
       "2                                           0.792988         \n",
       "3                                           0.811997         \n",
       "4                                           0.828573         \n",
       "5                                           0.844046         \n",
       "6                                           0.859433         \n",
       "7                                           0.875987         \n",
       "8                                           0.896521         "
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_success = 0.934 # 0.906 career, 0.934 season best\n",
    "num_trials = 7 * 17 # free throw attempts per game, 17 finals games per karl's career\n",
    "\n",
    "def optim_100_shots(p_success, num_trials, streak_length, target_prob):\n",
    "    return (prob_of_streak(num_trials, streak_length, prob_success = p_success, saved = None) -\n",
    "           target_prob) ** 2 \n",
    "    \n",
    "#scipy.optimize.minimize_scalar(optim_100_shots, bounds = (0.001, 0.999), method='bounded', \n",
    "#                               args = (num_trials, 100, 0.1), options={'xatol': 1e-05, 'maxiter': 500, 'disp': 1})\n",
    "\n",
    "target_probs = np.arange(0.1, 1.0, 0.1)\n",
    "pd.DataFrame({\"Overall Freethrow Accuracy\" : [str(np.round(target_prob * 100)) for target_prob in target_probs],\n",
    "            \"Probability of seeing 100-streak 4th Quarter in a season\" : \n",
    "              [scipy.optimize.minimize_scalar(optim_100_shots, bounds = (0.001, 0.999), method='bounded', \n",
    "                                args = (num_trials, 18, target_prob))['x'] \n",
    "             for target_prob in target_probs]})\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming a 75% career free-throw avg, Karl played better than his career average during the finals."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Simulated Streaks with Impurity\n",
    "What about streaks other than 100% pure success (or failure)?\n",
    "<br>Let's simulate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 2)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sim_streak_prob(p_success: float,\n",
    "                    k_successes: int,\n",
    "                    out_of_m_tries: int,\n",
    "                    num_trials: int):\n",
    "    \n",
    "    num_iters = 50000\n",
    "    prev = 1.0\n",
    "    current = 0.0    \n",
    "    iteration = 0\n",
    "    \n",
    "    while current != prev and iteration < 20:\n",
    "        iteration += 1\n",
    "        \n",
    "        prev = current\n",
    "    \n",
    "        run_matrix = ((np.random.uniform(size = (num_iters, num_trials)) # run matrix of random numbers\n",
    "                       < p_success).astype(int). # was trial successful?\n",
    "                      cumsum(axis = 1))          # cumsums of success\n",
    "        run_matrix[:, out_of_m_tries:] = run_matrix[:, out_of_m_tries:] - run_matrix[:, :-out_of_m_tries] # cumsum to rolling sum\n",
    "        run_matrix = (run_matrix >= k_successes).astype(int) # detect streaks during n events\n",
    "        run_matrix = (run_matrix.sum(axis = 1) >= 1).astype(int).mean() # average streaks over iters\n",
    "        current = prev * (iteration - 1) / iteration + run_matrix * 1 / iteration\n",
    "        current = np.round(current, 4)\n",
    "        \n",
    "    return current, iteration\n",
    "\n",
    "# probability of hitting 4-for-5\n",
    "sim_streak_prob(p_success = 0.35,\n",
    "                k_successes = 4,\n",
    "                out_of_m_tries = 5,\n",
    "                num_trials = 650)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Test on basketball__\n",
    "Compare to 9 out of 9 results from before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sim_streak_prob(p_success = 0., # field goal %\n",
    "                   k_successes = 100,\n",
    "                   out_of_m_tries = 100,\n",
    "                   num_trials = 7 * 82) # free throw attempts per game, games per season"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find most number of plate appearances where batter will only miss 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plate_appears = 3\n",
    "minus_1_result = 1.0\n",
    "\n",
    "while minus_1_result > 0.99:\n",
    "    plate_appears += 1\n",
    "    minus_1_result, _ = sim_streak_prob(p_success = 0.350, # field goal %\n",
    "                                        k_successes = plate_appears - 1,\n",
    "                                        out_of_m_tries = plate_appears,\n",
    "                                        num_trials = 650) # games per season\n",
    "plate_appears"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow- a .350 hitter should go 6-for-7 at least once in the season"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plate_appears = 3\n",
    "minus_1_result = 1.0\n",
    "\n",
    "while minus_1_result > 0.80:\n",
    "    plate_appears += 1\n",
    "    minus_1_result, _ = sim_streak_prob(p_success = 0.350, # field goal %\n",
    "                                        k_successes = plate_appears - 1,\n",
    "                                        out_of_m_tries = plate_appears,\n",
    "                                        num_trials = 650) # games per season\n",
    "plate_appears"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that same .350 hitter should only go 7-for-8 in 80% of seasons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_streak_prob(p_success = 0.53, # field goal %\n",
    "                   k_successes = 100,\n",
    "                   out_of_m_tries = 100,\n",
    "                   num_trials = 15 * 82) # games per season"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Chinese Restaurant\n",
    "https://en.wikipedia.org/wiki/Chinese_restaurant_process\n",
    "<br>discount, α, and strength, θ, defined for 0 ≤ α < 1 and θ > −α"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Base Solution__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[81, 13, 5, 1]"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "init_seating = [1]\n",
    "number_patrons = 100\n",
    "\n",
    "np.random.seed(1)\n",
    "seating = init_seating.copy()\n",
    "for i in range(number_patrons - 1):\n",
    "    seating += [1]\n",
    "    patrons_sat_sum = sum(seating)\n",
    "    patrons_sat_cumsum = np.cumsum(seating)\n",
    "    tmp = np.random.uniform()\n",
    "    seating[sum(patrons_sat_cumsum / patrons_sat_sum <= tmp)] = \\\n",
    "    seating[sum(patrons_sat_cumsum /patrons_sat_sum <= tmp)] + 1\n",
    "    if seating[-1] == 2:\n",
    "        seating[-1] = 1\n",
    "    else:\n",
    "        seating = seating[0:-1]\n",
    "            \n",
    "seating"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__General Solution__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[81, 13, 5, 1]"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "discount = 0 ## 0 by default\n",
    "strength = 1 ## 1 by default\n",
    "init_seating = [1]\n",
    "number_patrons = 100\n",
    "\n",
    "np.random.seed(1)\n",
    "seating = init_seating.copy()\n",
    "for i in range(number_patrons - 1):\n",
    "    patrons_sat_sum = sum(seating)\n",
    "    seating_probs = [(a - discount) / (patrons_sat_sum + strength) for a in seating] + \\\n",
    "    [(strength + len(seating) * discount) / (patrons_sat_sum + strength)]\n",
    "    seating_probs = np.cumsum(seating_probs)\n",
    "    tmp = np.random.uniform()\n",
    "    index_to_seat_at = sum(seating_probs <= tmp)\n",
    "    if index_to_seat_at == len(seating):\n",
    "        seating.append(1)\n",
    "    else:\n",
    "        seating[index_to_seat_at] = seating[index_to_seat_at] + 1\n",
    "    \n",
    "seating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "def general_chinese_prior_iter(number_patrons, discount = 0, strength = 1, func_seed = 1):\n",
    "    init_seating = [1]\n",
    "    np.random.seed(func_seed)\n",
    "    \n",
    "    seating = init_seating.copy()\n",
    "    for i in range(number_patrons - 1):\n",
    "        patrons_sat_sum = sum(seating)\n",
    "        seating_probs = [(a - discount) / (patrons_sat_sum + strength) for a in seating] + \\\n",
    "        [(strength + len(seating) * discount) / (patrons_sat_sum + strength)]\n",
    "        seating_probs = np.cumsum(seating_probs)\n",
    "        tmp = np.random.uniform()\n",
    "        index_to_seat_at = sum(seating_probs <= tmp)\n",
    "        if index_to_seat_at == len(seating):\n",
    "            seating.append(1)\n",
    "        else:\n",
    "            seating[index_to_seat_at] = seating[index_to_seat_at] + 1\n",
    "    \n",
    "    return seating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 9, 4, 2]\n",
      "[18, 2]\n",
      "[20]\n",
      "[4, 13, 1, 1, 1]\n",
      "[4, 8, 5, 2, 1]\n",
      "[12, 5, 3]\n",
      "[7, 10, 2, 1]\n",
      "[8, 9, 3]\n",
      "[2, 12, 4, 1, 1]\n",
      "[18, 2]\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(general_chinese_prior_iter(number_patrons = 20, func_seed = i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Dirichlet Process\n",
    "https://en.wikipedia.org/wiki/Dirichlet_process\n",
    "<br>base distributions in scipy\n",
    "<br>https://docs.scipy.org/doc/scipy/reference/stats.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 589,
   "metadata": {},
   "outputs": [],
   "source": [
    "dirichlet_obs = None\n",
    "\n",
    "def dirichlet_iter(base_dist = scipy.stats.norm.rvs, obs = None, scale = 1):\n",
    "    if obs is None:\n",
    "        obs = pd.DataFrame({\"value\": [base_dist()],\n",
    "                            \"count\": [1],\n",
    "                            \"pdf\": [1],             \n",
    "                            \"cdf\": [1]})\n",
    "    else:\n",
    "        tmp = np.random.uniform()\n",
    "        obs.loc[:, 'pdf'] = obs.loc[:,'count'] / (scale + sum(obs.loc[:,'count']) - 1 + 1)\n",
    "        obs.loc[:, 'cdf'] = np.cumsum(obs.loc[:, 'pdf'])\n",
    "        if tmp > max(obs.loc[:, 'cdf']):\n",
    "            value = base_dist()\n",
    "            if sum(obs.loc[:, 'value'] == value) == 0:\n",
    "                obs = pd.concat([obs,\n",
    "                                 pd.DataFrame({\"value\": [value],\n",
    "                                               \"count\": [1],\n",
    "                                               \"pdf\": [1],\n",
    "                                               \"cdf\": [1]})])\n",
    "                obs = obs.sort_values('value')\n",
    "            else:\n",
    "                obs.loc[obs['value'] == value, 'count'] = obs.loc[obs['value'] == value, 'count'] + 1\n",
    "        else:\n",
    "            ind_to_incr = sum(obs.loc[:, 'cdf'] <= tmp)\n",
    "            obs.iloc[ind_to_incr, obs.columns.get_loc('count')] = obs.loc[:, 'count'].iloc[ind_to_incr] + 1        \n",
    "        \n",
    "    return obs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 599,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>value</th>\n",
       "      <th>count</th>\n",
       "      <th>pdf</th>\n",
       "      <th>cdf</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.011184</td>\n",
       "      <td>1</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.813780</td>\n",
       "      <td>2</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.191391</td>\n",
       "      <td>47</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.094072</td>\n",
       "      <td>1</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.164440</td>\n",
       "      <td>30</td>\n",
       "      <td>0.29</td>\n",
       "      <td>0.80</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      value  count   pdf   cdf\n",
       "0 -1.011184      1  0.01  0.01\n",
       "0 -0.813780      2  0.02  0.03\n",
       "0 -0.191391     47  0.47  0.50\n",
       "0  0.094072      1  0.01  0.51\n",
       "0  0.164440     30  0.29  0.80"
      ]
     },
     "execution_count": 599,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_samples = 1000\n",
    "scale = 30\n",
    "dirich_df = dirichlet_iter(scale = scale)\n",
    "for i in range(num_samples - 1):\n",
    "    dirich_df = dirichlet_iter(obs = dirich_df, scale = scale)\n",
    "dirich.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 600,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dirichlet_values_list = []\n",
    "for i in list(dirich_df['value']):\n",
    "    dirichlet_values_list += [i, i, i]\n",
    "\n",
    "dirichlet_counts_list = []\n",
    "for i in list(dirich_df['count']):\n",
    "    dirichlet_counts_list += [0, i, 0]\n",
    "\n",
    "plt.plot(dirichlet_values_list, \n",
    "         dirichlet_counts_list,\n",
    "         #label = 'Dirichlet results',\n",
    "         linestyle = '-', #marker = '.', \n",
    "         color = 'blue')\n",
    "plt.xlabel('Value')\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Dirichlet Process Outcomes for ' + str(num_samples) + \" iterations and \" +\n",
    "         str(scale) + \" scale (alpha).\")\n",
    "#plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}