notebooks/Plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy.stats import pearsonr\n",
    "import glob\n",
    "import multiprocessing as MP\n",
    "import numpy as np\n",
    "import sklearn\n",
    "\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from scipy.stats import mannwhitneyu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_style('ticks')\n",
    "sns.set_palette('husl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 208 files.\n",
      "CPU times: user 1.88 ms, sys: 0 ns, total: 1.88 ms\n",
      "Wall time: 3.2 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "data_files = (\n",
    "    glob.glob('../data/spaced-algorithms/*.csv')\n",
    ")\n",
    "\n",
    "print('There are {} files.'.format(len(data_files)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 9.18 s, sys: 6.88 s, total: 16.1 s\n",
      "Wall time: 44.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Specifying the format is ~ 10x faster.\n",
    "swift_datetime_format = '%a %b %d %Y %H:%M:%S GMT+0000 (%Z)'\n",
    "\n",
    "def _worker_read_csv(filename):\n",
    "    df_tmp = pd.read_csv(filename)\n",
    "    df_tmp.datecreated = pd.to_datetime(df_tmp.datecreated, \n",
    "                                        format=swift_datetime_format)\n",
    "    df_tmp.dateinstallation = pd.to_datetime(df_tmp.dateinstallation, \n",
    "                                             format=swift_datetime_format)\n",
    "    return df_tmp\n",
    "\n",
    "with MP.Pool() as pool:\n",
    "    df = pd.concat(pool.map(_worker_read_csv, data_files))\n",
    "\n",
    "# df = pd.concat([pd.read_csv(f) for f in data_files])\n",
    "# df.datecreated = pd.to_datetime(df.datecreated)\n",
    "# df.dateinstallation = pd.to_datetime(df.dateinstallation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 21.9 s, sys: 3.57 s, total: 25.5 s\n",
      "Wall time: 25.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "multi_algo_users = df.groupby('user').algorithm.nunique()\n",
    "ignore_users = set(multi_algo_users[multi_algo_users > 1].reset_index().user.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 27.8 s, sys: 9.6 s, total: 37.4 s\n",
      "Wall time: 37.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "df2 = (\n",
    "    df[~df.user.isin(ignore_users)]\n",
    "    .rename(columns={\n",
    "        'correct': 'p_recall', \n",
    "        'datecreated': 'timestamp',\n",
    "        'user': 'user_id',\n",
    "        'question': 'lexeme_id',\n",
    "        'count': 'history_seen',\n",
    "        'language': 'learning_language'\n",
    "    })\n",
    ")\n",
    "\n",
    "df2['ui_language'] = 'de'\n",
    "df2['lexeme_string'] = df2['lexeme_id']\n",
    "df2['session_seen'] = 1\n",
    "df2['session_correct'] = df2['p_recall']\n",
    "df2['timestamp'] = df2['timestamp'].values.astype(np.int64) // 10 ** 9\n",
    "df2.sort_values(by=['user_id', 'lexeme_id', 'timestamp'], inplace=True)\n",
    "\n",
    "df2['delta'] = df2['timestamp'].diff()\n",
    "df2.loc[(df2.lexeme_id != df2.lexeme_id.shift()) | (df2.user_id != df2.user_id.shift()), 'delta'] = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Binned empirical forgetting rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 18.7 s, sys: 1.64 s, total: 20.4 s\n",
      "Wall time: 20.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "duration_grp = df2.groupby(['lexeme_id', 'user_id'])\n",
    "duration_df = (duration_grp.timestamp.last() - duration_grp.timestamp.first()).to_frame('timestamp')\n",
    "attempts_df = duration_grp.size().to_frame('attempts')\n",
    "attempt_duration = duration_df.join(attempts_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_term_users = set(duration_df[duration_df.timestamp > 3 * (1 - 0.25) * 86400].reset_index().user_id.unique().tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def limit_duration(days, alpha, attempts_exact=None):\n",
    "    secs = days * 24 * 60 * 60\n",
    "    lim = attempt_duration[(secs * (1 - alpha) < attempt_duration.timestamp) & (attempt_duration.timestamp < secs * (1 + alpha))]\n",
    "    if attempts_exact is not None:\n",
    "        lim = lim[lim.attempts == attempts_exact]\n",
    "    \n",
    "    lim = lim.reset_index()\n",
    "    valid_tuples = set((lim.lexeme_id + '/' + lim.user_id).values)\n",
    "    df_dur = df2[(df2.lexeme_id + '/' + df2.user_id).isin(valid_tuples)]\n",
    "    return df_dur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 33.8 s, sys: 7.88 s, total: 41.7 s\n",
      "Wall time: 41.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "P_MIN, P_MAX = 0.01, 0.99\n",
    "\n",
    "lexeme_init_grp = df2.sort_values('timestamp').groupby(['lexeme_id', 'user_id'])\n",
    "lexeme_initial = lexeme_init_grp.nth(2)\n",
    "lexeme_first = lexeme_init_grp.nth(1)\n",
    "lexeme_first_delta = (lexeme_initial.timestamp - lexeme_first.timestamp).dropna().to_frame('t_diff').reset_index()\n",
    "lexeme_initial = lexeme_initial.reset_index()\n",
    "\n",
    "lexeme_user_initial = lexeme_initial.copy()\n",
    "lexeme_user_initial['user_lexeme'] = lexeme_user_initial['user_id'] + '/' + lexeme_user_initial['lexeme_id']\n",
    "\n",
    "lexeme_user_initial['emp_n0'] = (\n",
    "    - np.log(np.maximum(P_MIN, np.minimum(P_MAX, lexeme_user_initial.p_recall.values.squeeze()))) /\n",
    "    (lexeme_first_delta.t_diff.values / (24 * 60 * 60))\n",
    ")\n",
    "lexeme_user_initial = lexeme_user_initial.set_index('user_lexeme')\n",
    "\n",
    "lexeme_emp_n0 = lexeme_user_initial.groupby('lexeme_id').emp_n0.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of how to bucket and calculate metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "days, N = 3, 5\n",
    "grp = limit_duration(days=days, alpha=0.1, attempts_exact=None).sort_values('timestamp').groupby(['lexeme_id', 'user_id'])\n",
    "nth = grp.nth(N)\n",
    "n_1th = grp.nth(N - 1)\n",
    "delta = (nth.timestamp - n_1th.timestamp).dropna().to_frame('t_diff').reset_index()\n",
    "nth = nth.reset_index()\n",
    "nth['emp_n'] = -np.log(np.maximum(P_MIN, np.minimum(P_MAX, nth['p_recall']))) / (delta.t_diff.values / (24 * 60 * 60))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "NORM_BY_INIT_N0 = True\n",
    "\n",
    "pm_frac = 0.25\n",
    "\n",
    "import warnings\n",
    "\n",
    "def _empirical_n_worker(params):\n",
    "    days, N = params\n",
    "    grp = limit_duration(days=days, alpha=pm_frac, attempts_exact=None).sort_values('timestamp').groupby(['lexeme_id', 'user_id'])\n",
    "    nth = grp.nth(N)\n",
    "    n_1th = grp.nth(N - 1)\n",
    "    delta = (nth.timestamp - n_1th.timestamp).dropna().to_frame('t_diff').reset_index()\n",
    "    nth = nth.reset_index()\n",
    "    \n",
    "    lexeme_emp_m = nth.groupby('lexeme_id').p_recall.mean()\n",
    "    \n",
    "    with warnings.catch_warnings():\n",
    "        warnings.simplefilter('ignore')\n",
    "        nth['emp_n'] = -np.log(np.maximum(P_MIN, np.minimum(P_MAX, nth['p_recall']))) / (delta.t_diff.values / (24 * 60 * 60))\n",
    "        if NORM_BY_INIT_N0:\n",
    "            nth['emp_n'] /= lexeme_emp_n0.loc[nth.lexeme_id].values\n",
    "        \n",
    "    ssig = {}\n",
    "    try:\n",
    "        for alg1, alg2 in [('smart', 'random'), ('spaced', 'random'), ('spaced', 'smart')]:\n",
    "            ssig[(alg1, alg2)] = mannwhitneyu(nth.emp_n[nth.algorithm == alg1], nth.emp_n[nth.algorithm == alg2])\n",
    "            \n",
    "        desc = (\n",
    "            nth # [\n",
    "                # nth.lexeme_id.isin(lexeme_emp_m.index[lexeme_emp_m > 0]) &\n",
    "                # nth.lexeme_id.isin(lexeme_initial_m.index[lexeme_initial_m > 0])\n",
    "                # ]\n",
    "            .groupby('algorithm')\n",
    "            .emp_n\n",
    "            .describe()\n",
    "        )\n",
    "    except Exception:\n",
    "        desc = None\n",
    "    \n",
    "    valid_lexeme_num = nth.lexeme_id.nunique()\n",
    "    return days, N, valid_lexeme_num, desc, ssig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 96.2 ms, sys: 7.35 s, total: 7.44 s\n",
      "Wall time: 19.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lexeme_data_2 = []\n",
    "# P_VALUE = 0.05\n",
    "P_VALUE = 0.05 / 36  # The Bonferroni procedure, m = number of tests = 36\n",
    "# P_VALUE = 1 - (1 - 0.05) ** (1 / 36) # The Šidák procedure\n",
    "\n",
    "with MP.Pool() as pool:\n",
    "    for days, N, valid_lexeme_num, desc, ssig in pool.map(\n",
    "        _empirical_n_worker,\n",
    "        [(days, N) for days in [3, 5, 9] for N in range(3, 9)]\n",
    "    ):\n",
    "        if desc is not None:\n",
    "            lexeme_data_2.append({\n",
    "                'N': N,\n",
    "                'days': days,\n",
    "                'valid_lexeme_num': valid_lexeme_num,\n",
    "                'smart_random_sig': ssig[('smart', 'random')].pvalue < P_VALUE,\n",
    "                'spaced_smart_sig': ssig[('spaced', 'smart')].pvalue < P_VALUE,\n",
    "                'spaced_random_sig': ssig[('spaced', 'random')].pvalue < P_VALUE,\n",
    "            })\n",
    "            \n",
    "            for alg in ['smart', 'random', 'spaced']:\n",
    "                for field in ['count', '25%', '50%', '75%', 'mean']:\n",
    "                    lexeme_data_2[-1][f'{alg}_{field}'] = desc[field][alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "binned_df_2 = pd.DataFrame(lexeme_data_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spaced median empirical forgetting rate is better in 83.3% of the cases against smart.\n"
     ]
    }
   ],
   "source": [
    "print(f\"spaced median empirical forgetting rate is better in {round(binned_df_2[binned_df_2['spaced_50%'] < binned_df_2['smart_50%']].shape[0] / binned_df_2.shape[0] * 100., 1)}% of the cases against smart.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spaced median empirical forgetting rate is better in 72.2% of the cases against smart and the decrease is statistically significant.\n"
     ]
    }
   ],
   "source": [
    "print(f\"spaced median empirical forgetting rate is better in {round(binned_df_2[(binned_df_2['spaced_50%'] < binned_df_2['smart_50%']) & (binned_df_2['spaced_smart_sig'])].shape[0] / binned_df_2.shape[0] * 100., 1)}% of the cases against smart and the decrease is statistically significant.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spaced median empirical forgetting rate is better in 83.3% of the cases against random.\n"
     ]
    }
   ],
   "source": [
    "print(f\"spaced median empirical forgetting rate is better in {round(binned_df_2[binned_df_2['spaced_50%'] < binned_df_2['random_50%']].shape[0] / binned_df_2.shape[0] * 100., 1)}% of the cases against random.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spaced median empirical forgetting rate is better in 61.1% of the cases against random and the decrease is statistically significant.\n"
     ]
    }
   ],
   "source": [
    "print(f\"spaced median empirical forgetting rate is better in {round(binned_df_2[(binned_df_2['spaced_50%'] < binned_df_2['random_50%']) & (binned_df_2['spaced_random_sig'])].shape[0] / binned_df_2.shape[0] * 100., 1)}% of the cases against random and the decrease is statistically significant.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666666"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(binned_df_2[(binned_df_2['spaced_50%'] < binned_df_2['random_50%']) & (binned_df_2['spaced_random_sig'])].shape[0] + binned_df_2[(binned_df_2['spaced_50%'] < binned_df_2['smart_50%']) & (binned_df_2['spaced_smart_sig'])].shape[0]) / (2 * binned_df_2.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing median decrease in normalized empirical forgetting rate and median increase in the half-life of 'spaced' against 'random'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4801462337059099"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - (binned_df_2['spaced_50%'] / binned_df_2['random_50%']).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.923617880329606"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1. / (binned_df_2['spaced_50%'] / binned_df_2['random_50%']).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9236334147366407"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1. / (binned_df_2['spaced_50%'] / binned_df_2['random_50%'])).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing median decrease in normalized empirical forgetting rate and median increase in the half-life of 'spaced' against 'smart'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4094175923621066"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - (binned_df_2['spaced_50%'] / binned_df_2['smart_50%']).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6932437997935332"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1. / (binned_df_2['spaced_50%'] / binned_df_2['smart_50%']).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.697376781839326"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1. / (binned_df_2['spaced_50%'] / binned_df_2['smart_50%'])).median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create figure and axes\n",
    "\n",
    "def label_diff(algo, X, Y_1, Y_2, W, repetitions, day):\n",
    "    for i in range(repetitions):\n",
    "        is_sig = binned_df_2[(binned_df_2.days == day)]['spaced_' + algo + '_sig'].values[i]\n",
    "        y = 1.1 * max(Y_1[i], Y_2[i])\n",
    "\n",
    "        props = {\n",
    "            'connectionstyle': 'bar',\n",
    "            'arrowstyle': '-',\n",
    "            'shrinkA': 0,\n",
    "            'shrinkB': 0,\n",
    "            'linewidth': 0.6,\n",
    "            'color': 'black'\n",
    "        }\n",
    "\n",
    "        if is_sig:\n",
    "            plt.gca().annotate(\"*\", xy=(X[i] - W / 2 - 0.02, y * 1.2), zorder=10, fontsize=13)\n",
    "        plt.gca().annotate('', xy=(X[i] - W, y), xytext=(X[i] + 0.25 * W, y), color='k',\n",
    "                           arrowprops=props)\n",
    "\n",
    "ALG_LABEL = {\n",
    "    'spaced': r'\\textsc{Select}',\n",
    "    'smart': 'difficulty',\n",
    "    'random': 'random'\n",
    "}\n",
    "\n",
    "def plot_day_perf(day, with_ylabel=True, with_legend=True):\n",
    "    clrs = sns.color_palette('Set2', n_colors=3)\n",
    "    df_plot = binned_df_2[(binned_df_2.days == day)]\n",
    "    for idx, alg in enumerate(['random', 'spaced', 'smart']):\n",
    "        yerr = np.vstack([\n",
    "            df_plot[f'{alg}_50%'] - df_plot[f'{alg}_25%'],\n",
    "            df_plot[f'{alg}_75%'] - df_plot[f'{alg}_50%']\n",
    "        ])\n",
    "        plt.errorbar(\n",
    "            x=df_plot['N'] - 1 - (idx - 1) * 0.2, \n",
    "            y=df_plot[f'{alg}_50%'], \n",
    "            yerr=yerr,\n",
    "            color=clrs[idx],\n",
    "            label=ALG_LABEL[alg],\n",
    "            fmt='x',\n",
    "            elinewidth=12,\n",
    "            alpha=0.2,\n",
    "        )\n",
    "        if alg == 'random':\n",
    "            label_diff(\n",
    "                algo=alg, \n",
    "                X=(df_plot['N'] - 1 - (idx - 1) * 0.2).values,\n",
    "                Y_1=df_plot[f'{alg}_75%'].values,\n",
    "                Y_2=df_plot[f'spaced_75%'].values,\n",
    "                W = 0.2,\n",
    "                repetitions=df_plot.shape[0],\n",
    "                day=day\n",
    "            )\n",
    "        elif alg == 'spaced':\n",
    "             label_diff(\n",
    "                algo='smart', \n",
    "                X=(df_plot['N'] - 1 - (idx - 1) * 0.2).values,\n",
    "                Y_1=df_plot[f'{alg}_75%'].values,\n",
    "                Y_2=df_plot[f'smart_75%'].values,\n",
    "                W = 0.2,\n",
    "                repetitions=df_plot.shape[0],\n",
    "                day=day\n",
    "            )\n",
    "        plt.scatter(\n",
    "            df_plot['N'] - 1 - (idx - 1) * 0.2,\n",
    "            df_plot[f'{alg}_50%'],\n",
    "            marker='x',\n",
    "            color=clrs[idx],\n",
    "            label=None\n",
    "        )\n",
    "    plt.yscale('log')\n",
    "    plt.xlabel(r'\\# reviews')\n",
    "    if with_ylabel:\n",
    "        plt.ylabel('$\\hat{n}$' if not NORM_BY_INIT_N0 else r'${\\hat{n}}\\ /\\ {\\hat{n}_0}$')\n",
    "    plt.title(f'$T = {day} \\\\pm {round(pm_frac * day, 1)}$ days')\n",
    "    \n",
    "    if with_legend:\n",
    "        plt.legend(loc='lower right')\n",
    "        \n",
    "    sns.despine()\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_width = 4 * 3.39 / 1.1\n",
    "fig_height = (np.sqrt(5) - 1) * 3 / 1.1\n",
    "figsize = (fig_width, fig_height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 887.564x242.719 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams.update({\"text.usetex\": True})\n",
    "fig = plt.figure(figsize=figsize)\n",
    "plt.subplot(131)\n",
    "plot_day_perf(3, with_legend=False)\n",
    "plt.subplot(132)\n",
    "plot_day_perf(5, with_ylabel=False, with_legend=False)\n",
    "plt.subplot(133)\n",
    "plot_day_perf(9, with_ylabel=False, with_legend=True)\n",
    "plt.tight_layout()\n",
    "# plt.savefig('all-T.pdf', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple regression + Response Variance "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 processed.\n",
      "4 processed.\n",
      "5 processed.\n",
      "6 processed.\n",
      "7 processed.\n",
      "8 processed.\n",
      "CPU times: user 18.3 s, sys: 15.1 s, total: 33.4 s\n",
      "Wall time: 58.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression, HuberRegressor\n",
    "\n",
    "grp = df2[df2.algorithm.isin(['smart', 'spaced', 'random'])].groupby(['lexeme_id', 'user_id'])\n",
    "one_hot_encoder = OneHotEncoder(drop=['spaced']).fit(np.array(['spaced', 'random', 'smart']).reshape(-1, 1))\n",
    "reg_factory = lambda: HuberRegressor(fit_intercept=True)\n",
    "# reg_factory = lambda: LinearRegression(fit_intercept=True)\n",
    "\n",
    "first = grp.nth(1)  # The first attempt for each lexeme for each user.\n",
    "\n",
    "coefs_ = {}\n",
    "regs = {}\n",
    "response_description = {}\n",
    "difficulty_description = {}\n",
    "ys = {}\n",
    "Xs = {}\n",
    "ssigs = {}\n",
    "\n",
    "def regression(N):\n",
    "    reg = reg_factory()\n",
    "    nth = grp.nth(N)\n",
    "    n_1th = grp.nth(N - 1)\n",
    "    test_time = (nth.timestamp - n_1th.timestamp).dropna().to_frame('t_diff').reset_index()\n",
    "    lexeme_users_with_tests = test_time.lexeme_id + '/' + test_time.user_id\n",
    "\n",
    "    review_time_all = (n_1th.timestamp - first.timestamp).dropna().to_frame('time').reset_index()\n",
    "    review_time = review_time_all[\n",
    "        (review_time_all.lexeme_id + '/' + review_time_all.user_id)\n",
    "        .isin(lexeme_users_with_tests.values)\n",
    "    ]\n",
    "\n",
    "    nth = nth.reset_index()\n",
    "    nth['emp_n0'] = lexeme_emp_n0[nth.lexeme_id].values\n",
    "    emp_n = (\n",
    "        -np.log(np.maximum(P_MIN, np.minimum(P_MAX, nth['p_recall']))) / (test_time.t_diff.values / (24 * 60 * 60))\n",
    "    )\n",
    "    \n",
    "     ssig = {}\n",
    "     for alg1, alg2 in [('smart', 'random'), ('spaced', 'random'), ('spaced', 'smart')]:\n",
    "         ssig[(alg1, alg2)] = mannwhitneyu(nth.emp_n0[nth.algorithm == alg1], nth.emp_n0[nth.algorithm == alg2])\n",
    "    \n",
    "    y = emp_n / lexeme_emp_n0[nth.lexeme_id].values\n",
    "    T = review_time.time.values / (24 * 60 * 60)\n",
    "    T_median = T - np.median(T)\n",
    "    alg = nth.algorithm.values.reshape(-1, 1)\n",
    "    alg_feat = one_hot_encoder.transform(alg)\n",
    "    X = np.hstack([T_median.reshape(-1, 1), alg_feat.todense()])\n",
    "    reg.fit(X, y)\n",
    "    \n",
    "    return (N, nth, y, X, reg, ssig)\n",
    "\n",
    "\n",
    "with MP.Pool() as pool:\n",
    "    for (N, nth, y, X, reg, ssig) in pool.map(regression, range(3, 9)):\n",
    "        response_description[N] = nth.groupby('algorithm').p_recall.describe()\n",
    "        difficulty_description[N] = nth.groupby('algorithm').emp_n0.describe()\n",
    "        regs[N] = reg\n",
    "        coefs_[N] = reg.coef_\n",
    "        ys[N] = y\n",
    "        Xs[N] = X\n",
    "        ssigs[N] = ssig\n",
    "\n",
    "        print(f\"{N} processed.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array(['random', 'smart', 'spaced'], dtype='<U6')]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot_encoder.categories_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['spaced'],\n",
       "       ['random'],\n",
       "       ['smart']], dtype='<U6')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_hot_encoder.inverse_transform([[0, 0], [1, 0], [0, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coefs_[3].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `T - T_{median}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FR_3 = 0.0025851 + -0.0000198 * (T - T_{median}) + 0.0002434 * I[random] + 0.0002250 * I[smart]\n",
      "FR_4 = 0.0032134 + -0.0000220 * (T - T_{median}) + 0.0001268 * I[random] + 0.0002731 * I[smart]\n",
      "FR_5 = 0.0030441 + -0.0000217 * (T - T_{median}) + 0.0006490 * I[random] + 0.0006731 * I[smart]\n",
      "FR_6 = 0.0030312 + -0.0000220 * (T - T_{median}) + 0.0011450 * I[random] + 0.0009979 * I[smart]\n",
      "FR_7 = 0.0036860 + -0.0000226 * (T - T_{median}) + 0.0006395 * I[random] + 0.0007695 * I[smart]\n",
      "FR_8 = 0.0038292 + -0.0000251 * (T - T_{median}) + 0.0011158 * I[random] + 0.0013460 * I[smart]\n"
     ]
    }
   ],
   "source": [
    "for N in regs:\n",
    "    reg = regs[N]\n",
    "    print(f'FR_{N} = {reg.intercept_:0.7f} + {reg.coef_[0]:0.7f} * (T - T_{{median}}) + {reg.coef_[1]:0.7f} * I[random] + {reg.coef_[2]:0.7f} * I[smart]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The responses are too noisy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>93636.0</td>\n",
       "      <td>0.803291</td>\n",
       "      <td>0.397512</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>301954.0</td>\n",
       "      <td>0.804308</td>\n",
       "      <td>0.396733</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>69236.0</td>\n",
       "      <td>0.801173</td>\n",
       "      <td>0.399121</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count      mean       std  min  25%  50%  75%  max\n",
       "algorithm                                                       \n",
       "random      93636.0  0.803291  0.397512  0.0  1.0  1.0  1.0  1.0\n",
       "smart      301954.0  0.804308  0.396733  0.0  1.0  1.0  1.0  1.0\n",
       "spaced      69236.0  0.801173  0.399121  0.0  1.0  1.0  1.0  1.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_description[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>53946.0</td>\n",
       "      <td>0.810829</td>\n",
       "      <td>0.391648</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>181162.0</td>\n",
       "      <td>0.808210</td>\n",
       "      <td>0.393710</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>44425.0</td>\n",
       "      <td>0.811548</td>\n",
       "      <td>0.391077</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count      mean       std  min  25%  50%  75%  max\n",
       "algorithm                                                       \n",
       "random      53946.0  0.810829  0.391648  0.0  1.0  1.0  1.0  1.0\n",
       "smart      181162.0  0.808210  0.393710  0.0  1.0  1.0  1.0  1.0\n",
       "spaced      44425.0  0.811548  0.391077  0.0  1.0  1.0  1.0  1.0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_description[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>33815.0</td>\n",
       "      <td>0.82351</td>\n",
       "      <td>0.381242</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>118675.0</td>\n",
       "      <td>0.81242</td>\n",
       "      <td>0.390378</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>31207.0</td>\n",
       "      <td>0.82004</td>\n",
       "      <td>0.384160</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count     mean       std  min  25%  50%  75%  max\n",
       "algorithm                                                      \n",
       "random      33815.0  0.82351  0.381242  0.0  1.0  1.0  1.0  1.0\n",
       "smart      118675.0  0.81242  0.390378  0.0  1.0  1.0  1.0  1.0\n",
       "spaced      31207.0  0.82004  0.384160  0.0  1.0  1.0  1.0  1.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_description[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>22650.0</td>\n",
       "      <td>0.830022</td>\n",
       "      <td>0.375622</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>82305.0</td>\n",
       "      <td>0.815054</td>\n",
       "      <td>0.388256</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>22573.0</td>\n",
       "      <td>0.830151</td>\n",
       "      <td>0.375508</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count      mean       std  min  25%  50%  75%  max\n",
       "algorithm                                                      \n",
       "random     22650.0  0.830022  0.375622  0.0  1.0  1.0  1.0  1.0\n",
       "smart      82305.0  0.815054  0.388256  0.0  1.0  1.0  1.0  1.0\n",
       "spaced     22573.0  0.830151  0.375508  0.0  1.0  1.0  1.0  1.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_description[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>15799.0</td>\n",
       "      <td>0.837901</td>\n",
       "      <td>0.368553</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>59107.0</td>\n",
       "      <td>0.816671</td>\n",
       "      <td>0.386939</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>17089.0</td>\n",
       "      <td>0.831529</td>\n",
       "      <td>0.374295</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count      mean       std  min  25%  50%  75%  max\n",
       "algorithm                                                      \n",
       "random     15799.0  0.837901  0.368553  0.0  1.0  1.0  1.0  1.0\n",
       "smart      59107.0  0.816671  0.386939  0.0  1.0  1.0  1.0  1.0\n",
       "spaced     17089.0  0.831529  0.374295  0.0  1.0  1.0  1.0  1.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_description[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>11289.0</td>\n",
       "      <td>0.842944</td>\n",
       "      <td>0.363869</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>44535.0</td>\n",
       "      <td>0.821107</td>\n",
       "      <td>0.383267</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>13514.0</td>\n",
       "      <td>0.840018</td>\n",
       "      <td>0.366603</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count      mean       std  min  25%  50%  75%  max\n",
       "algorithm                                                      \n",
       "random     11289.0  0.842944  0.363869  0.0  1.0  1.0  1.0  1.0\n",
       "smart      44535.0  0.821107  0.383267  0.0  1.0  1.0  1.0  1.0\n",
       "spaced     13514.0  0.840018  0.366603  0.0  1.0  1.0  1.0  1.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_description[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Median difficulty of `spaced` is larger than `smart` and the difference is statistically significant.\n",
    "But the difference is less extreme between `spaced` and `random`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>93636.0</td>\n",
       "      <td>156.389901</td>\n",
       "      <td>315.457521</td>\n",
       "      <td>0.000257</td>\n",
       "      <td>41.515357</td>\n",
       "      <td>100.821579</td>\n",
       "      <td>196.468424</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>301954.0</td>\n",
       "      <td>152.335195</td>\n",
       "      <td>335.913867</td>\n",
       "      <td>0.000305</td>\n",
       "      <td>35.744616</td>\n",
       "      <td>94.241640</td>\n",
       "      <td>184.925492</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>69236.0</td>\n",
       "      <td>156.670494</td>\n",
       "      <td>320.449471</td>\n",
       "      <td>0.002473</td>\n",
       "      <td>41.891584</td>\n",
       "      <td>101.266918</td>\n",
       "      <td>195.875268</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count        mean         std       min        25%         50%  \\\n",
       "algorithm                                                                      \n",
       "random      93636.0  156.389901  315.457521  0.000257  41.515357  100.821579   \n",
       "smart      301954.0  152.335195  335.913867  0.000305  35.744616   94.241640   \n",
       "spaced      69236.0  156.670494  320.449471  0.002473  41.891584  101.266918   \n",
       "\n",
       "                  75%          max  \n",
       "algorithm                           \n",
       "random     196.468424  5696.039452  \n",
       "smart      184.925492  5696.039452  \n",
       "spaced     195.875268  5696.039452  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difficulty_description[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>53946.0</td>\n",
       "      <td>161.463943</td>\n",
       "      <td>331.015418</td>\n",
       "      <td>0.003677</td>\n",
       "      <td>41.891584</td>\n",
       "      <td>101.985193</td>\n",
       "      <td>197.803668</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>181162.0</td>\n",
       "      <td>154.025928</td>\n",
       "      <td>336.966692</td>\n",
       "      <td>0.000305</td>\n",
       "      <td>38.496791</td>\n",
       "      <td>95.898215</td>\n",
       "      <td>186.077401</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>44425.0</td>\n",
       "      <td>157.616913</td>\n",
       "      <td>308.254542</td>\n",
       "      <td>0.002711</td>\n",
       "      <td>41.891584</td>\n",
       "      <td>103.393861</td>\n",
       "      <td>197.803668</td>\n",
       "      <td>5422.140080</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count        mean         std       min        25%         50%  \\\n",
       "algorithm                                                                      \n",
       "random      53946.0  161.463943  331.015418  0.003677  41.891584  101.985193   \n",
       "smart      181162.0  154.025928  336.966692  0.000305  38.496791   95.898215   \n",
       "spaced      44425.0  157.616913  308.254542  0.002711  41.891584  103.393861   \n",
       "\n",
       "                  75%          max  \n",
       "algorithm                           \n",
       "random     197.803668  5696.039452  \n",
       "smart      186.077401  5696.039452  \n",
       "spaced     197.803668  5422.140080  "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difficulty_description[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>33815.0</td>\n",
       "      <td>162.075510</td>\n",
       "      <td>324.949744</td>\n",
       "      <td>0.003677</td>\n",
       "      <td>41.891584</td>\n",
       "      <td>103.827552</td>\n",
       "      <td>198.983210</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>118675.0</td>\n",
       "      <td>153.174289</td>\n",
       "      <td>327.530755</td>\n",
       "      <td>0.002711</td>\n",
       "      <td>38.624822</td>\n",
       "      <td>96.597275</td>\n",
       "      <td>185.387810</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>31207.0</td>\n",
       "      <td>158.482178</td>\n",
       "      <td>312.713507</td>\n",
       "      <td>0.002727</td>\n",
       "      <td>41.891584</td>\n",
       "      <td>104.208995</td>\n",
       "      <td>197.803668</td>\n",
       "      <td>5422.140080</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count        mean         std       min        25%         50%  \\\n",
       "algorithm                                                                      \n",
       "random      33815.0  162.075510  324.949744  0.003677  41.891584  103.827552   \n",
       "smart      118675.0  153.174289  327.530755  0.002711  38.624822   96.597275   \n",
       "spaced      31207.0  158.482178  312.713507  0.002727  41.891584  104.208995   \n",
       "\n",
       "                  75%          max  \n",
       "algorithm                           \n",
       "random     198.983210  5696.039452  \n",
       "smart      185.387810  5696.039452  \n",
       "spaced     197.803668  5422.140080  "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difficulty_description[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>22650.0</td>\n",
       "      <td>159.055326</td>\n",
       "      <td>315.561502</td>\n",
       "      <td>0.003677</td>\n",
       "      <td>41.515357</td>\n",
       "      <td>102.890631</td>\n",
       "      <td>196.468424</td>\n",
       "      <td>5074.677048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>82305.0</td>\n",
       "      <td>154.136428</td>\n",
       "      <td>332.763470</td>\n",
       "      <td>0.002711</td>\n",
       "      <td>38.624822</td>\n",
       "      <td>96.685378</td>\n",
       "      <td>183.847002</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>22573.0</td>\n",
       "      <td>160.029695</td>\n",
       "      <td>319.592537</td>\n",
       "      <td>0.003107</td>\n",
       "      <td>42.127365</td>\n",
       "      <td>106.071437</td>\n",
       "      <td>197.924957</td>\n",
       "      <td>5422.140080</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count        mean         std       min        25%         50%  \\\n",
       "algorithm                                                                     \n",
       "random     22650.0  159.055326  315.561502  0.003677  41.515357  102.890631   \n",
       "smart      82305.0  154.136428  332.763470  0.002711  38.624822   96.685378   \n",
       "spaced     22573.0  160.029695  319.592537  0.003107  42.127365  106.071437   \n",
       "\n",
       "                  75%          max  \n",
       "algorithm                           \n",
       "random     196.468424  5074.677048  \n",
       "smart      183.847002  5696.039452  \n",
       "spaced     197.924957  5422.140080  "
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difficulty_description[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>algorithm</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>random</th>\n",
       "      <td>15799.0</td>\n",
       "      <td>155.326173</td>\n",
       "      <td>308.043959</td>\n",
       "      <td>0.014519</td>\n",
       "      <td>41.515357</td>\n",
       "      <td>101.187132</td>\n",
       "      <td>191.373765</td>\n",
       "      <td>5074.677048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smart</th>\n",
       "      <td>59107.0</td>\n",
       "      <td>154.350271</td>\n",
       "      <td>331.020767</td>\n",
       "      <td>0.003677</td>\n",
       "      <td>40.324890</td>\n",
       "      <td>97.904414</td>\n",
       "      <td>183.279687</td>\n",
       "      <td>5696.039452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spaced</th>\n",
       "      <td>17089.0</td>\n",
       "      <td>159.954807</td>\n",
       "      <td>311.201253</td>\n",
       "      <td>0.003107</td>\n",
       "      <td>41.891584</td>\n",
       "      <td>106.071437</td>\n",
       "      <td>200.072901</td>\n",
       "      <td>5422.140080</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count        mean         std       min        25%         50%  \\\n",
       "algorithm                                                                     \n",
       "random     15799.0  155.326173  308.043959  0.014519  41.515357  101.187132   \n",
       "smart      59107.0  154.350271  331.020767  0.003677  40.324890   97.904414   \n",
       "spaced     17089.0  159.954807  311.201253  0.003107  41.891584  106.071437   \n",
       "\n",
       "                  75%          max  \n",
       "algorithm                           \n",
       "random     191.373765  5074.677048  \n",
       "smart      183.279687  5696.039452  \n",
       "spaced     200.072901  5422.140080  "
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difficulty_description[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: {('smart',\n",
       "   'random'): MannwhitneyuResult(statistic=1603752.0, pvalue=0.26206792498748166),\n",
       "  ('spaced',\n",
       "   'random'): MannwhitneyuResult(statistic=287797.5, pvalue=8.165173812281938e-05),\n",
       "  ('spaced',\n",
       "   'smart'): MannwhitneyuResult(statistic=1114062.0, pvalue=2.6892165135626432e-05)},\n",
       " 4: {('smart',\n",
       "   'random'): MannwhitneyuResult(statistic=1603752.0, pvalue=0.26206792498748166),\n",
       "  ('spaced',\n",
       "   'random'): MannwhitneyuResult(statistic=287797.5, pvalue=8.165173812281938e-05),\n",
       "  ('spaced',\n",
       "   'smart'): MannwhitneyuResult(statistic=1114062.0, pvalue=2.6892165135626432e-05)},\n",
       " 5: {('smart',\n",
       "   'random'): MannwhitneyuResult(statistic=1603752.0, pvalue=0.26206792498748166),\n",
       "  ('spaced',\n",
       "   'random'): MannwhitneyuResult(statistic=287797.5, pvalue=8.165173812281938e-05),\n",
       "  ('spaced',\n",
       "   'smart'): MannwhitneyuResult(statistic=1114062.0, pvalue=2.6892165135626432e-05)},\n",
       " 6: {('smart',\n",
       "   'random'): MannwhitneyuResult(statistic=1603752.0, pvalue=0.26206792498748166),\n",
       "  ('spaced',\n",
       "   'random'): MannwhitneyuResult(statistic=287797.5, pvalue=8.165173812281938e-05),\n",
       "  ('spaced',\n",
       "   'smart'): MannwhitneyuResult(statistic=1114062.0, pvalue=2.6892165135626432e-05)},\n",
       " 7: {('smart',\n",
       "   'random'): MannwhitneyuResult(statistic=1603752.0, pvalue=0.26206792498748166),\n",
       "  ('spaced',\n",
       "   'random'): MannwhitneyuResult(statistic=287797.5, pvalue=8.165173812281938e-05),\n",
       "  ('spaced',\n",
       "   'smart'): MannwhitneyuResult(statistic=1114062.0, pvalue=2.6892165135626432e-05)},\n",
       " 8: {('smart',\n",
       "   'random'): MannwhitneyuResult(statistic=1603752.0, pvalue=0.26206792498748166),\n",
       "  ('spaced',\n",
       "   'random'): MannwhitneyuResult(statistic=287797.5, pvalue=8.165173812281938e-05),\n",
       "  ('spaced',\n",
       "   'smart'): MannwhitneyuResult(statistic=1114062.0, pvalue=2.6892165135626432e-05)}}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ssigs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Individual FR plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 14min 43s, sys: 14min 48s, total: 29min 31s\n",
      "Wall time: 1min 7s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 427.382x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "N = 3\n",
    "(N, nth, y, X, reg, ssig) = regression(N=N)\n",
    "coef_ = reg.coef_\n",
    "T = np.array(X[:, 0]).squeeze()\n",
    "alg = one_hot_encoder.inverse_transform(X[:, 1:]).squeeze()\n",
    "idx = (y < np.percentile(y, 95))  # Reject the top x% of values.\n",
    "clrs = sns.color_palette('Set2', n_colors=3)\n",
    "color_map = {'smart': clrs[0], 'spaced': clrs[1], 'random': clrs[2]}\n",
    "plot_data = pd.DataFrame.from_records([{'Algorithm': algo, 'T': T, 'FR': fr} for (algo, T, fr) in zip(alg.squeeze()[idx], T[idx], y[idx])])\n",
    "splot = sns.lmplot(x=\"T\", y=\"FR\", hue=\"Algorithm\", data=plot_data, palette=color_map, scatter_kws={'alpha': 0.01})\n",
    "splot.set(yscale='log') # , xscale='log')\n",
    "splot.set(title=f'FR against review time (\\\\#reviews = {N - 1})')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    464826.000000\n",
       "mean          5.227634\n",
       "std          14.957487\n",
       "min          -1.051030\n",
       "25%          -1.001678\n",
       "50%           0.000000\n",
       "75%           4.089777\n",
       "max         199.929444\n",
       "dtype: float64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(T).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    1799.000000\n",
       "mean      119.546290\n",
       "std       338.516848\n",
       "min         0.000257\n",
       "25%         2.061961\n",
       "50%        40.590857\n",
       "75%       132.207625\n",
       "max      5696.039452\n",
       "Name: emp_n0, dtype: float64"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lexeme_emp_n0.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    4.648260e+05\n",
       "mean     1.786863e+00\n",
       "std      5.102000e+01\n",
       "min      1.415011e-08\n",
       "25%      4.728363e-05\n",
       "50%      5.974014e-04\n",
       "75%      1.447973e-02\n",
       "max      1.551676e+04\n",
       "Name: p_recall, dtype: float64"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    373551\n",
       "0     91275\n",
       "Name: p_recall, dtype: int64"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nth['p_recall'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((464826,), (464826,), (464826,))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alg.shape, T.shape, y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2058436365090057"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.percentile(y, 95)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}