Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "\n",
    "import pickle as pk\n",
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategy Comparisons\n",
    "\n",
    "We're going to compare the effectiveness of the \"best guess\", \"best answer\", and \"random answer\" strategies. We can load our simulation results from `strategy_simulations.py`. To compare against our personal baseline, we'll need to bootstrap from my historical distribution since I haven't played every possible wordle game. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#strategies to compare\n",
    "strategy_list = [\"best_guess\", \"best_answer\", \"random_answer\", \"personal\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#my personal performance, num_turns: number of times I won in that number of turns. \n",
    "\n",
    "my_performance = {1:0, 2: 0, 3:3, 4:6, 5:6, 6:1, 7:1}\n",
    "\n",
    "my_turn_dist = []\n",
    "for turn, count in my_performance.items():\n",
    "    my_turn_dist.extend([turn]*count)\n",
    "    \n",
    "my_turn_dist = np.asarray(my_turn_dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_words = 2315 \n",
    "\n",
    "df_list = []\n",
    "\n",
    "for rep in range(10):\n",
    "    for strategy in strategy_list:\n",
    "        \n",
    "        #bootstrap\n",
    "        if strategy == \"personal\":\n",
    "            num_turns = np.random.choice(my_turn_dist, num_words)\n",
    "        \n",
    "        #load simulation results\n",
    "        else:\n",
    "            fp = \"results/{}_strategy_full_results_rep={}.pk\".format(strategy, rep)\n",
    "            full_results = pk.load(open(fp, \"rb\"))\n",
    "\n",
    "            num_turns = np.asarray([int(len(x)/2) for x in full_results.values()])\n",
    "        \n",
    "        df = pd.DataFrame()\n",
    "        df['num_turns'] = num_turns\n",
    "        df['rep'] = rep\n",
    "        df['strategy'] = strategy\n",
    "\n",
    "        df_list.append(df)\n",
    "        \n",
    "full_df = pd.concat(df_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>num_turns</th>\n",
       "      <th>rep</th>\n",
       "      <th>strategy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>best_guess</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>best_guess</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>best_guess</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>best_guess</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>best_guess</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   num_turns  rep    strategy\n",
       "0          3    0  best_guess\n",
       "1          3    0  best_guess\n",
       "2          3    0  best_guess\n",
       "3          3    0  best_guess\n",
       "4          3    0  best_guess"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization\n",
    "\n",
    "Now that we're finished loading in the data, let's visualize the results!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ugly hack for making sure that x-axis is the same for everybody. \n",
    "\n",
    "from itertools import product\n",
    "\n",
    "reps, num_turns = np.arange(10), np.arange(1,full_df['num_turns'].max() + 1)\n",
    "\n",
    "reps_by_turns = []\n",
    "for a, b in product(reps, num_turns): reps_by_turns.append([a,b])\n",
    "reps_by_turns = np.asarray(reps_by_turns)\n",
    "\n",
    "empty_df = pd.DataFrame({'num_turns': reps_by_turns[:,1],\n",
    "                         'rep': reps_by_turns[:,0]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting script\n",
    "\n",
    "plt.rcParams[\"font.family\"] = \"serif\"\n",
    "\n",
    "pretty_strategy = {\"best_guess\": \"best guess\", \n",
    "                   \"best_answer\": \"best answer\",\n",
    "                   \"random_answer\": \"random answer\",\n",
    "                   \"personal\": \"personal\"}\n",
    "\n",
    "fig, axes = plt.subplots(ncols = 4, figsize = (16,4), sharex=True)\n",
    "\n",
    "fig.add_subplot(111, frameon=False)\n",
    "\n",
    "for idx, (ax, strategy) in enumerate(zip(axes, strategy_list)):\n",
    "    \n",
    "    data = full_df[full_df['strategy'] == strategy][[\"num_turns\", \"rep\"]]\n",
    "    result_df = data.groupby(['num_turns', 'rep']).size().reset_index(name='count')\n",
    "    result_df['count'] = result_df['count']/num_words\n",
    "    \n",
    "    merged_df = pd.merge(empty_df, result_df, on = ['num_turns', 'rep'], how = \"left\")\n",
    "    merged_df = merged_df.fillna(0)\n",
    "    \n",
    "    mean_std = data['num_turns']\n",
    "    \n",
    "    mean, std = np.mean(data['num_turns'].values), np.std(data['num_turns'].values)\n",
    "    \n",
    "    ax.set_title(\"{}\".format(pretty_strategy[strategy]), fontsize = 18, pad = 10)\n",
    "\n",
    "    sns.barplot(data = merged_df, x = \"num_turns\", y = \"count\", \n",
    "                width = 0.9, dodge = False, ax = ax)\n",
    "    ax.text(4, 0.45, '{:.2f} +/- {:.2f} \\n guesses'.format(mean, std), size=15, color='black')\n",
    "    ax.set_ylim(0.0, 0.55)\n",
    "    \n",
    "for idx, ax in enumerate(axes.flatten()):\n",
    "    ax.set_ylabel(\"\")\n",
    "    ax.set_xlabel(\"\")\n",
    "        \n",
    "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
    "plt.ylabel(\"Proportion\", fontsize = 15)\n",
    "plt.xlabel(\"Number of Guesses\", fontsize = 15)\n",
    "    \n",
    "plt.savefig(\"results/simulation_results.png\", dpi = 300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistical Testing\n",
    "\n",
    "The story is pretty clear from the visualization, but we can also run a statistical test. In this case, since we have the strategy results for every wordle word, we can use a paired statistical test. i.e., for any given word, I can compare the performance of each strategy (except personal) on that word. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_rel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_two_strategies(strategy1, strategy2):\n",
    "    \n",
    "    x = full_df[full_df['strategy'] == strategy1]['num_turns'].values\n",
    "    y = full_df[full_df['strategy'] == strategy2]['num_turns'].values\n",
    "    \n",
    "    return ttest_rel(x, y, alternative = \"less\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_relResult(statistic=-20.456898423901464, pvalue=1.7051179721031718e-92)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_two_strategies(\"best_guess\", \"best_answer\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_relResult(statistic=-57.47149829315941, pvalue=0.0)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_two_strategies(\"best_answer\", \"random_answer\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_relResult(statistic=-40.824800750295, pvalue=0.0)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_two_strategies(\"random_answer\", \"personal\")"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}