black_jack.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function lists out all permutations of ace values in the array sum_array\n",
    "# For example, if you have 2 aces, there are 4 permutations:\n",
    "#     [[1,1], [1,11], [11,1], [11,11]]\n",
    "# These permutations lead to 3 unique sums: [2, 12, 22]\n",
    "# Of these 3, only 2 are <=21 so they are returned: [2, 12]\n",
    "def get_ace_values(temp_list):\n",
    "    sum_array = np.zeros((2**len(temp_list), len(temp_list)))\n",
    "    # This loop gets the permutations\n",
    "    for i in range(len(temp_list)):\n",
    "        n = len(temp_list) - i\n",
    "        half_len = int(2**n * 0.5)\n",
    "        for rep in range(int(sum_array.shape[0]/half_len/2)):\n",
    "            sum_array[rep*2**n : rep*2**n+half_len, i] = 1\n",
    "            sum_array[rep*2**n+half_len : rep*2**n+half_len*2, i] = 11\n",
    "    # Only return values that are valid (<=21)\n",
    "    return list(set([int(s) for s in np.sum(sum_array, axis=1) if s<=21]))\n",
    "\n",
    "# Convert num_aces, an int to a list of lists\n",
    "# For example if num_aces=2, the output should be [[1,11],[1,11]]\n",
    "# I require this format for the get_ace_values function\n",
    "def ace_values(num_aces):\n",
    "    temp_list = []\n",
    "    for i in range(num_aces):\n",
    "        temp_list.append([1,11])\n",
    "    return get_ace_values(temp_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a deck\n",
    "def make_decks(num_decks, card_types):\n",
    "    new_deck = []\n",
    "    for i in range(num_decks):\n",
    "        for j in range(4):\n",
    "            new_deck.extend(card_types)\n",
    "    random.shuffle(new_deck)\n",
    "    return new_deck\n",
    "\n",
    "# Total up value of hand\n",
    "def total_up(hand):\n",
    "    aces = 0\n",
    "    total = 0\n",
    "    \n",
    "    for card in hand:\n",
    "        if card != 'A':\n",
    "            total += card\n",
    "        else:\n",
    "            aces += 1\n",
    "    \n",
    "    # Call function ace_values to produce list of possible values for aces in hand\n",
    "    ace_value_list = ace_values(aces)\n",
    "    final_totals = [i+total for i in ace_value_list if i+total<=21]\n",
    "    \n",
    "    if final_totals == []:\n",
    "        return min(ace_value_list) + total\n",
    "    else:\n",
    "        return max(final_totals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "stacks = 50000\n",
    "players = 1\n",
    "num_decks = 1\n",
    "\n",
    "card_types = ['A',2,3,4,5,6,7,8,9,10,10,10,10]\n",
    "\n",
    "dealer_card_feature = []\n",
    "player_card_feature = []\n",
    "player_results = []\n",
    "\n",
    "for stack in range(stacks):\n",
    "    blackjack = set(['A',10])\n",
    "    dealer_cards = make_decks(num_decks, card_types)\n",
    "    while len(dealer_cards) > 20:\n",
    "        \n",
    "        curr_player_results = np.zeros((1,players))\n",
    "        \n",
    "        dealer_hand = []\n",
    "        player_hands = [[] for player in range(players)]\n",
    "\n",
    "        # Deal FIRST card\n",
    "        for player, hand in enumerate(player_hands):\n",
    "            player_hands[player].append(dealer_cards.pop(0))\n",
    "        dealer_hand.append(dealer_cards.pop(0))\n",
    "        # Deal SECOND card\n",
    "        for player, hand in enumerate(player_hands):\n",
    "            player_hands[player].append(dealer_cards.pop(0))\n",
    "        dealer_hand.append(dealer_cards.pop(0))\n",
    "\n",
    "        # Dealer checks for 21\n",
    "        if set(dealer_hand) == blackjack:\n",
    "            for player in range(players):\n",
    "                if set(player_hands[player]) != blackjack:\n",
    "                    curr_player_results[0,player] = -1\n",
    "                else:\n",
    "                    curr_player_results[0,player] = 0\n",
    "        else:\n",
    "            for player in range(players):\n",
    "                # Players check for 21\n",
    "                if set(player_hands[player]) == blackjack:\n",
    "                    curr_player_results[0,player] = 1\n",
    "                else:\n",
    "                    # Hit randomly, check for busts\n",
    "                    while (random.random() >= 0.5) and (total_up(player_hands[player]) != 21):\n",
    "                        player_hands[player].append(dealer_cards.pop(0))\n",
    "                        if total_up(player_hands[player]) > 21:\n",
    "                            curr_player_results[0,player] = -1\n",
    "                            break\n",
    "        \n",
    "        # Dealer hits based on the rules\n",
    "        while total_up(dealer_hand) < 17:\n",
    "            dealer_hand.append(dealer_cards.pop(0))\n",
    "        # Compare dealer hand to players hand but first check if dealer busted\n",
    "        if total_up(dealer_hand) > 21:\n",
    "            for player in range(players):\n",
    "                if curr_player_results[0,player] != -1:\n",
    "                    curr_player_results[0,player] = 1\n",
    "        else:\n",
    "            for player in range(players):\n",
    "                if total_up(player_hands[player]) > total_up(dealer_hand):\n",
    "                    if total_up(player_hands[player]) <= 21:\n",
    "                        curr_player_results[0,player] = 1\n",
    "                elif total_up(player_hands[player]) == total_up(dealer_hand):\n",
    "                    curr_player_results[0,player] = 0\n",
    "                else:\n",
    "                    curr_player_results[0,player] = -1\n",
    "        #print('player: ' + str(total_up(player_hands[player])),\n",
    "        #      'dealer: ' + str(total_up(dealer_hand)),\n",
    "        #      'result: ' + str(curr_player_results)\n",
    "        #     )    \n",
    "        \n",
    "        # Track features\n",
    "        dealer_card_feature.append(dealer_hand[0])\n",
    "        player_card_feature.append(player_hands)\n",
    "        player_results.append(list(curr_player_results[0]))\n",
    "\n",
    "model_df = pd.DataFrame()\n",
    "model_df['dealer_card'] = dealer_card_feature\n",
    "model_df['player_total_initial'] = [total_up(i[0][0:2]) for i in player_card_feature]\n",
    "model_df['Y'] = [i[0] for i in player_results]\n",
    "\n",
    "lose = []\n",
    "for i in model_df['Y']:\n",
    "    if i == -1:\n",
    "        lose.append(1)\n",
    "    else:\n",
    "        lose.append(0)\n",
    "model_df['lose'] = lose\n",
    "\n",
    "has_ace = []\n",
    "for i in player_card_feature:\n",
    "    if ('A' in i[0][0:2]):\n",
    "        has_ace.append(1)\n",
    "    else:\n",
    "        has_ace.append(0)\n",
    "model_df['has_ace'] = has_ace\n",
    "\n",
    "dealer_card_num = []\n",
    "for i in model_df['dealer_card']:\n",
    "    if i=='A':\n",
    "        dealer_card_num.append(11)\n",
    "    else:\n",
    "        dealer_card_num.append(i)\n",
    "model_df['dealer_card_num'] = dealer_card_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "312518"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(pd.DataFrame(player_results)[0].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0    199607\n",
       " 1.0     99449\n",
       " 0.0     13462\n",
       "Name: 0, dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(player_results)[0].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = 1 - (model_df.groupby(by='dealer_card').sum()['lose'] /\\\n",
    "            model_df.groupby(by='dealer_card').count()['lose'])\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10,6))\n",
    "ax = sns.barplot(x=data.index, \n",
    "                 y=data.values)\n",
    "ax.set_xlabel(\"Dealer's Card\",fontsize=16)\n",
    "ax.set_ylabel(\"Probability of Tie or Win\",fontsize=16)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(fname='dealer_card_probs', dpi=150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = 1 - (model_df.groupby(by='player_total_initial').sum()['lose'] /\\\n",
    "            model_df.groupby(by='player_total_initial').count()['lose'])\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10,6))\n",
    "ax = sns.barplot(x=data[:-1].index,\n",
    "                 y=data[:-1].values)\n",
    "ax.set_xlabel(\"Player's Hand Value\",fontsize=16)\n",
    "ax.set_ylabel(\"Probability of Tie or Win\",fontsize=16)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(fname='player_hand_probs', dpi=150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "has_ace\n",
       "0    0.683229\n",
       "1    0.384232\n",
       "Name: lose, dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_df.groupby(by='has_ace').sum()['lose'] / model_df.groupby(by='has_ace').count()['lose']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pivot_data = model_df[model_df['player_total_initial'] != 21]\n",
    "\n",
    "losses_pivot = pd.pivot_table(pivot_data, values='lose', \n",
    "                              index=['dealer_card_num'],\n",
    "                              columns = ['player_total_initial'],\n",
    "                              aggfunc = np.sum)\n",
    "\n",
    "games_pivot =  pd.pivot_table(pivot_data, values='lose', \n",
    "                              index=['dealer_card_num'],\n",
    "                              columns = ['player_total_initial'],\n",
    "                              aggfunc = 'count')\n",
    "\n",
    "heat_data = 1 - losses_pivot.sort_index(ascending=False) / games_pivot.sort_index(ascending=False)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,8))\n",
    "sns.heatmap(heat_data, square=False, cmap=\"PiYG\");\n",
    "\n",
    "ax.set_xlabel(\"Player's Hand Value\",fontsize=16)\n",
    "ax.set_ylabel(\"Dealer's Card\",fontsize=16)\n",
    "\n",
    "plt.savefig(fname='heat_map_random', dpi=150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "stacks = 50000\n",
    "players = 1\n",
    "num_decks = 1\n",
    "\n",
    "card_types = ['A',2,3,4,5,6,7,8,9,10,10,10,10]\n",
    "\n",
    "dealer_card_feature = []\n",
    "player_card_feature = []\n",
    "player_results = []\n",
    "\n",
    "for stack in range(stacks):\n",
    "    blackjack = set(['A',10])\n",
    "    dealer_cards = make_decks(num_decks, card_types)\n",
    "    while len(dealer_cards) > 20:\n",
    "        \n",
    "        curr_player_results = np.zeros((1,players))\n",
    "        \n",
    "        dealer_hand = []\n",
    "        player_hands = [[] for player in range(players)]\n",
    "\n",
    "        # Deal FIRST card\n",
    "        for player, hand in enumerate(player_hands):\n",
    "            player_hands[player].append(dealer_cards.pop(0))\n",
    "        dealer_hand.append(dealer_cards.pop(0))\n",
    "        # Deal SECOND card\n",
    "        for player, hand in enumerate(player_hands):\n",
    "            player_hands[player].append(dealer_cards.pop(0))\n",
    "        dealer_hand.append(dealer_cards.pop(0))\n",
    "\n",
    "        # Dealer checks for 21\n",
    "        if set(dealer_hand) == blackjack:\n",
    "            for player in range(players):\n",
    "                if set(player_hands[player]) != blackjack:\n",
    "                    curr_player_results[0,player] = -1\n",
    "                else:\n",
    "                    curr_player_results[0,player] = 0\n",
    "        else:\n",
    "            for player in range(players):\n",
    "                # Players check for 21\n",
    "                if set(player_hands[player]) == blackjack:\n",
    "                    curr_player_results[0,player] = 1\n",
    "                else:\n",
    "                    # Hit only when we know we will not bust\n",
    "                    while total_up(player_hands[player]) <= 11:\n",
    "                        player_hands[player].append(dealer_cards.pop(0))\n",
    "                        if total_up(player_hands[player]) > 21:\n",
    "                            curr_player_results[0,player] = -1\n",
    "                            break\n",
    "        \n",
    "        # Dealer hits based on the rules\n",
    "        while total_up(dealer_hand) < 17:\n",
    "            dealer_hand.append(dealer_cards.pop(0))\n",
    "        # Compare dealer hand to players hand but first check if dealer busted\n",
    "        if total_up(dealer_hand) > 21:\n",
    "            for player in range(players):\n",
    "                if curr_player_results[0,player] != -1:\n",
    "                    curr_player_results[0,player] = 1\n",
    "        else:\n",
    "            for player in range(players):\n",
    "                if total_up(player_hands[player]) > total_up(dealer_hand):\n",
    "                    if total_up(player_hands[player]) <= 21:\n",
    "                        curr_player_results[0,player] = 1\n",
    "                elif total_up(player_hands[player]) == total_up(dealer_hand):\n",
    "                    curr_player_results[0,player] = 0\n",
    "                else:\n",
    "                    curr_player_results[0,player] = -1\n",
    "        #print('player: ' + str(total_up(player_hands[player])),\n",
    "        #      'dealer: ' + str(total_up(dealer_hand)),\n",
    "        #      'result: ' + str(curr_player_results)\n",
    "        #     )    \n",
    "        \n",
    "        # Track features\n",
    "        dealer_card_feature.append(dealer_hand[0])\n",
    "        player_card_feature.append(player_hands)\n",
    "        player_results.append(list(curr_player_results[0]))\n",
    "\n",
    "model_df_smart = pd.DataFrame()\n",
    "model_df_smart['dealer_card'] = dealer_card_feature\n",
    "model_df_smart['player_total_initial'] = [total_up(i[0][0:2]) for i in player_card_feature]\n",
    "model_df_smart['Y'] = [i[0] for i in player_results]\n",
    "\n",
    "lose = []\n",
    "for i in model_df_smart['Y']:\n",
    "    if i == -1:\n",
    "        lose.append(1)\n",
    "    else:\n",
    "        lose.append(0)\n",
    "model_df_smart['lose'] = lose\n",
    "\n",
    "has_ace = []\n",
    "for i in player_card_feature:\n",
    "    if ('A' in i[0][0:2]):\n",
    "        has_ace.append(1)\n",
    "    else:\n",
    "        has_ace.append(0)\n",
    "model_df_smart['has_ace'] = has_ace\n",
    "\n",
    "dealer_card_num = []\n",
    "for i in model_df_smart['dealer_card']:\n",
    "    if i=='A':\n",
    "        dealer_card_num.append(11)\n",
    "    else:\n",
    "        dealer_card_num.append(i)\n",
    "model_df_smart['dealer_card_num'] = dealer_card_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_smart = 1 - (model_df_smart.groupby(by='dealer_card_num').sum()['lose'] /\\\n",
    "                  model_df_smart.groupby(by='dealer_card_num').count()['lose'])\n",
    "data_random = 1 - (model_df.groupby(by='dealer_card_num').sum()['lose'] /\\\n",
    "                   model_df.groupby(by='dealer_card_num').count()['lose'])\n",
    "\n",
    "data = pd.DataFrame()\n",
    "data['smart'] = data_smart\n",
    "data['random'] = data_random\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,6))\n",
    "ax.bar(x=data.index-0.2, height=data['smart'].values, color='blue', width=0.4, label='Smart')\n",
    "ax.bar(x=data.index+0.2, height=data['random'].values, color='red', width=0.4, label='Coin Flip')\n",
    "ax.set_xlabel(\"Dealer's Card\",fontsize=16)\n",
    "ax.set_ylabel(\"Probability of Tie or Win\",fontsize=16)\n",
    "plt.xticks(np.arange(2, 12, 1.0))\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.savefig(fname='dealer_card_probs_smart', dpi=150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_smart = 1 - (model_df_smart.groupby(by='player_total_initial').sum()['lose'] /\\\n",
    "                  model_df_smart.groupby(by='player_total_initial').count()['lose'])\n",
    "data_random = 1 - (model_df.groupby(by='player_total_initial').sum()['lose'] /\\\n",
    "                   model_df.groupby(by='player_total_initial').count()['lose'])\n",
    "\n",
    "data = pd.DataFrame()\n",
    "data['smart'] = data_smart[:-1]\n",
    "data['random'] = data_random[:-1]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,6))\n",
    "ax.bar(x=data.index-0.2, height=data['smart'].values, color='blue', width=0.4, label='Smart')\n",
    "ax.bar(x=data.index+0.2, height=data['random'].values, color='red', width=0.4, label='Coin Flip')\n",
    "ax.set_xlabel(\"Player's Hand Value\",fontsize=16)\n",
    "ax.set_ylabel(\"Probability of Tie or Win\",fontsize=16)\n",
    "plt.xticks(np.arange(4, 21, 1.0))\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.savefig(fname='player_hand_probs_smart', dpi=150)"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}