AITraining.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "### cs109default ### \n",
    "import random\n",
    "random.seed(112358)\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import copy\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.utils import resample\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.linear_model import LogisticRegressionCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.preprocessing import scale\n",
    "from sklearn.metrics import roc_auc_score,accuracy_score\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from random import randint \n",
    "from sklearn import tree\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "pd.set_option('display.width', 1500)\n",
    "pd.set_option('display.max_columns', 100)\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_artifacts = 4\n",
    "class Card:\n",
    "    def __init__(self, points, danger, artifact):\n",
    "        # Number of points\n",
    "        self.points = points\n",
    "        # Type of danger (choose from 5)\n",
    "        self.danger = danger\n",
    "        # Is it an artifact or not\n",
    "        self.artifact = artifact\n",
    "\n",
    "    def show(self):\n",
    "        # Show value of card:\n",
    "        if self.points != 0:\n",
    "            print(\"Treasure! Value: {}\".format(self.points))\n",
    "        if self.danger != None:\n",
    "            print(\"Danger: {}\".format(self.danger))\n",
    "        if self.artifact:\n",
    "            print(\"Artifact\")\n",
    "\n",
    "dangers = ['Mummy', \"Fire\", \"Avalanche\", \"Serpent\", \"Spiders\"]\n",
    "\n",
    "num_dangers = 3\n",
    "\n",
    "players = ['A','B', 'C', 'D', 'E']\n",
    "\n",
    "class Deck:\n",
    "    def __init__(self, num_artifacts):\n",
    "        self.cards = []\n",
    "        self.build()\n",
    "\n",
    "    def build(self):\n",
    "        # Insert Dangers\n",
    "        for danger in dangers:\n",
    "            for i in range(0, num_dangers):\n",
    "                self.cards.append(Card(0, danger, None))\n",
    "        #Insert treasure cards\n",
    "        treasures = [1,2,3,4,5,5,7,7,9,11,11,13,14,15,17]\n",
    "        for treasure in treasures:\n",
    "                self.cards.append(Card(treasure, None, None))\n",
    "        #Insert Artifacts\n",
    "        for i in range (0, num_artifacts):\n",
    "            self.cards.append(Card(0, None, True))\n",
    "\n",
    "    def shows(self):\n",
    "        for c in self.cards:\n",
    "            c.show()\n",
    "            \n",
    "    def shuffle(self):\n",
    "        for i in range(len(self.cards) -1, 0, -1):\n",
    "            r = random.randint(0,i)\n",
    "            #Swap cards\n",
    "            self.cards[i], self.cards[r] = self.cards[r], self.cards[i]\n",
    "    def draw (self):\n",
    "        return self.cards.pop()\n",
    "\n",
    "\n",
    "class Player:\n",
    "    def __init__(self, player, strat):\n",
    "        self.name = player\n",
    "        self.score = 0\n",
    "        self.loot = 0\n",
    "        # Variables AI can use to make decisions\n",
    "        self.number_dangers = 0\n",
    "        self.num_players = 0\n",
    "        self.expected_value = 0\n",
    "        self.leader_score = 0\n",
    "        self.strat = strat#str(input(\"Enter Strategy: \"))\n",
    "        self.prob_dying = 0\n",
    "        # Extra gold to be gained from going back\n",
    "        self.extra = 0\n",
    "        self.num_artifacts = 0\n",
    "        self.round_number = 1\n",
    "        self.decision_df = pd.DataFrame(columns = ['score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts', 'round_number'])\n",
    "    # Choice of whether to go forward or backward\n",
    "    # https://gist.github.com/garrettdreyfus/8153571\n",
    "    # If player type is normal, propmpts user for input, else makes choice\n",
    "    # based off of AI strategy\n",
    "    def choose(self):\n",
    "        if self.strat == \"normal\":\n",
    "            while \"invalid\":\n",
    "                print(\"Make a choice {}\".format(self.name))\n",
    "                print(\"Your current score is {}\". format(self.score))\n",
    "                print(\"Your current loot is {}\\n\\n\\n\\n\\n\".format(self.loot))\n",
    "                check = str(input(\"Proceed into Temple? (Y/N):\")).lower().strip()\n",
    "                if check[0] == 'y':\n",
    "                    return True\n",
    "                elif check[0] == 'n':\n",
    "                    return False\n",
    "                else:\n",
    "                    print('Invalid Input')\n",
    "        elif self.strat == \"AI Basic\":\n",
    "\n",
    "            a = random.random()\n",
    "            if a < 0.8:\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "                                        \n",
    "        elif self.strat == \"AI 2nd-Gen\":\n",
    "            self.decision_df = self.decision_df.append({'score':self.score, 'loot':self.loot, 'num_dangers':self.number_dangers, 'num_players':self.num_players, 'expected_value':self.expected_value, 'leader_score':self.leader_score, 'prob_dying':self.prob_dying, 'extra':self.extra, 'num_artifacts':self.num_artifacts,'round_number':self.round_number}, ignore_index = True)\n",
    "            y_predict = (gen2.predict_proba(self.decision_df)>0.675)[0][1]\n",
    "            # Clear dataframe = \n",
    "            self.decision_df = pd.DataFrame(columns = ['score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts', 'round_number'])\n",
    "            a = random.random()\n",
    "            if a < 0.9:\n",
    "                return y_predict\n",
    "            else:\n",
    "                return not y_predict\n",
    "        elif self.strat == 'AI 3rd-Gen':\n",
    "            self.decision_df = self.decision_df.append({'score':self.score, 'loot':self.loot, 'num_dangers':self.number_dangers, 'num_players':self.num_players, 'expected_value':self.expected_value, 'leader_score':self.leader_score, 'prob_dying':self.prob_dying, 'extra':self.extra, 'num_artifacts':self.num_artifacts,'round_number':self.round_number}, ignore_index = True)\n",
    "            y_predict = (gen3.predict_proba(self.decision_df)>0.675)[0][1]\n",
    "            # Clear dataframe = \n",
    "            self.decision_df = pd.DataFrame(columns = ['score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts', 'round_number'])\n",
    "            a = random.random()\n",
    "            if a < 0.9:\n",
    "                return y_predict\n",
    "            else:\n",
    "                return not y_predict\n",
    "            \n",
    "            \n",
    "    # Player gains loot from treasure cards\n",
    "    def add_loot(self, loot_share):\n",
    "        self.loot += loot_share\n",
    "    # Player retreats and transfers loot to tent\n",
    "\n",
    "    def retreat(self):\n",
    "        # Convert loot to score\n",
    "        self.score += self.loot\n",
    "        # Set loot = to 0 \n",
    "        self.loot = 0\n",
    "\n",
    "    def die(self):\n",
    "        self.loot = 0\n",
    "\n",
    "# Game engines runs a game\n",
    "class Game:\n",
    "    # Input number of players\n",
    "    def __init__(self, player_number):\n",
    "        self.players = []\n",
    "        for i in range(0, player_number):\n",
    "            player = Player(players[i], strategies[i])\n",
    "            self.players.append(player)\n",
    "        # Create player object for each player\n",
    "        self.round_results = pd.DataFrame(columns = ['name','score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts', 'round_number','decision'])\n",
    "        self.game_results = pd.DataFrame(columns = ['name','score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts', 'round_number','decision'])\n",
    "        # Round function\n",
    "        self.artifacts_taken = 0 \n",
    "        \n",
    "    def Round(self,round_number):\n",
    "        # Build and shuffle a deck\n",
    "        #print('Round {}:'.format(round_number))\n",
    "        #Create Dataframe to store results\n",
    "        results_temp = self.round_results\n",
    "        deck = Deck(round_number - self.artifacts_taken)\n",
    "        deck.shuffle()\n",
    "        extra = 0\n",
    "        dangers_ = []\n",
    "        num_artifacts = 0\n",
    "        counter = 0\n",
    "        # Total Value of all treasure cards\n",
    "        value = 124\n",
    "        # Repeat until all players have left or death occurs\n",
    "        while \"round is active\":\n",
    "        # Get input from all players\n",
    "            if counter == 0:\n",
    "                # Active players will be a list of the indices of the players in self.players who are active\n",
    "                active_players = [i for i in range(0, len(self.players))]\n",
    "\n",
    "            counter += 1\n",
    "            # List of players who are leaving\n",
    "            leaving_players = []\n",
    "\n",
    "            for player in active_players:\n",
    "                choice = self.players[player].choose()\n",
    "                #print(active_players)\n",
    "                if choice == False:\n",
    "                    results_temp = results_temp.append({'name':self.players[player].name,'score':self.players[player].score, 'loot':self.players[player].loot, 'num_dangers':self.players[player].number_dangers, 'num_players':self.players[player].num_players, 'expected_value':self.players[player].expected_value, 'leader_score':self.players[player].leader_score, 'prob_dying':self.players[player].prob_dying, 'extra':self.players[player].extra, 'num_artifacts':self.players[player].num_artifacts,'round_number':round_number, 'decision': 0},ignore_index = True)\n",
    "                    # Update players still in game\n",
    "                    leaving_players.append(player)\n",
    "                elif choice == True:\n",
    "                    results_temp = results_temp.append({'name':self.players[player].name,'score':self.players[player].score, 'loot':self.players[player].loot, 'num_dangers':self.players[player].number_dangers, 'num_players':self.players[player].num_players, 'expected_value':self.players[player].expected_value, 'leader_score':self.players[player].leader_score, 'prob_dying':self.players[player].prob_dying, 'extra':self.players[player].extra, 'num_artifacts':self.players[player].num_artifacts,'round_number':round_number, 'decision': 1},ignore_index = True)\n",
    "                    # Remove player from active players\n",
    "                    # Why is this removing from self.players as well\n",
    "            for player in leaving_players:\n",
    "                active_players.remove(player)\n",
    "            # Handle Leaving players\n",
    "            num_leaving = len(leaving_players)\n",
    "            if num_leaving != 0:\n",
    "                leaving_split = math.floor(extra/num_leaving)\n",
    "                if num_artifacts != 0:\n",
    "                    artifact_split = math.floor(num_artifacts/num_leaving)\n",
    "                    self.artifacts_taken = self.artifacts_taken + num_artifacts\n",
    "                    if artifact_split !=0:\n",
    "                        num_artifacts = num_artifacts % artifact_split\n",
    "                else:\n",
    "                    artifact_split = 0\n",
    "            else:\n",
    "                leaving_split = 0\n",
    "            if leaving_split != 0:\n",
    "                extra = extra % leaving_split\n",
    "            for player in leaving_players:\n",
    "                self.players[player].add_loot(leaving_split)\n",
    "                if self.artifacts_taken < 4:\n",
    "                    self.players[player].add_loot(5 * artifact_split)\n",
    "                else:\n",
    "                    self.players[player].add_loot(10 * artifact_split)\n",
    "                self.players[player].retreat()\n",
    "            # Make sure there are players still active\n",
    "            num_players = len(active_players)\n",
    "            if (num_players == 0):\n",
    "                self.game_results = self.game_results.append(results_temp, ignore_index = True)\n",
    "                active_players =  [i for i in range(0, len(self.players))]\n",
    "                return False\n",
    "            # Draw card off of deck\n",
    "            card = deck.draw()\n",
    "            #card.show()\n",
    "            # If danger update danger\n",
    "            if card.danger != None:\n",
    "                # If death end round\n",
    "                if card.danger in dangers_:\n",
    "                    #print(\"You died to {}\".format(card.danger))\n",
    "                    self.game_results = self.game_results.append(results_temp, ignore_index = True)\n",
    "                    for player in active_players:\n",
    "                        self.players[player].die()\n",
    "                    active_players = [i for i in range(0, len(self.players))]\n",
    "                    return False\n",
    "                else:\n",
    "                    dangers_.append(card.danger)\n",
    "            # If card is artifact, print number of artifacts.\n",
    "\n",
    "            if card.artifact:\n",
    "                num_artifacts += 1\n",
    "\n",
    "            # If treasure split treasures\n",
    "            split = math.floor(card.points / num_players)\n",
    "\n",
    "            # Add loot for active players\n",
    "            for player in active_players:\n",
    "                self.players[player].add_loot(split)\n",
    "            # Update treaure on path\n",
    "            extra += (card.points % num_players)\n",
    "\n",
    "            # Calculate Expected value of next card\n",
    "            value = value - card.points\n",
    "            # 30 - counter is the number of cards left in deck\n",
    "            ev = value/(30 - counter)\n",
    "            # Calculate score of player in the lead\n",
    "            scores = []\n",
    "            for player in self.players:\n",
    "                scores.append(player.score)\n",
    "            prob_dying = (2*len(dangers_))/(30-counter)\n",
    "            # Update player objects with information that they can make decicions off of\n",
    "            for player in active_players:\n",
    "                self.players[player].number_dangers = len(dangers_)\n",
    "                self.players[player].num_players = len(active_players)\n",
    "                self.players[player].expected_value = ev\n",
    "                self.players[player].leader_score = max(scores)\n",
    "                self.players[player].prob_dying = prob_dying\n",
    "                self.players[player].extra = extra\n",
    "                self.players[player].num_artifacts = num_artifacts\n",
    "                self.players[player].round_number = round_number\n",
    "        \n",
    "\n",
    "    # Run Appropriate Number of Rounds\n",
    "    def play_game(self):\n",
    "        # Run 4 Rounds\n",
    "        for i in range(0,5):\n",
    "            self.Round(i+1)\n",
    "\n",
    "        scores = []\n",
    "        #print(self.players)\n",
    "        for player in self.players:\n",
    "            #print(\"{} has {} points\".format(player.name, player.score))\n",
    "            scores.append(player.score)\n",
    "            player.score = 0\n",
    "        winner = self.players[scores.index(max(scores))].name\n",
    "        #print(\"Winner is {}\".format(winner))\n",
    "        winner_results = self.game_results[self.game_results['name'] == winner]\n",
    "        self.game_results = pd.DataFrame(columns = ['name','score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts', 'round_number','decision'])\n",
    "        return winner, winner_results\n",
    "        # Update results dataframe with moves made by winning plater\n",
    "        \n",
    "\n",
    "    # Tally scoress and declare winner.\n",
    "# Implements a single round of the game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# First Generation\n",
    "Play AIs making random moves against each other and record the set of moves made by the winning player "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "results1 = pd.DataFrame(columns = ['name','score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts','round_number', 'decision'])\n",
    "strategies = ['AI Basic' for i in range(0, 5)]\n",
    "winners = []\n",
    "for i in range(0,2000):\n",
    "    game = Game(5)\n",
    "    winner, result = game.play_game()\n",
    "    winners.append(winner)\n",
    "    results1 = results1.append(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "results1.to_csv('Data/gen_1.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([400, 378, 394, 411, 417])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "freqs = Counter(winners)\n",
    "freqs.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot Winning Frequencies\n",
    "y = np.array([400, 378, 394, 411, 417])/2000\n",
    "# Make the plot\n",
    "x = [i for i, _ in enumerate(strategies)]\n",
    "plt.bar(x, y, linewidth=3, linestyle=\"--\",\n",
    "         color=\"blue\", alpha = 0.5)\n",
    "plt.xlabel(r\"Strategy\")\n",
    "plt.ylabel(r\"Winning Percentage\")\n",
    "plt.title(r\"Generation 1 Results\")\n",
    "plt.legend(loc=\"lower left\")\n",
    "plt.xticks(x, strategies)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Second Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train RF model off of winning moves from first generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "results1 = results1.drop('name', axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict correct move from inputs using logistic regression\n",
    "X_train, X_test, y_train, y_test =train_test_split(results1.loc[:, results1.columns != 'decision'], \n",
    "                                                         results1.decision, test_size=0.2, \n",
    "                                                         random_state = 109\n",
    "                                                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=10, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=55,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train = y_train.astype('int')\n",
    "y_test = y_test.astype('int')\n",
    "random_forest = RandomForestClassifier(n_estimators = 55, max_depth = 10, max_features = 'auto') \n",
    "random_forest.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "import joblib\n",
    "joblib.dump(random_forest, 'Models/gen2')\n",
    "gen2 = joblib.load('Models/gen2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8261240144896654"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen2.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "results2 = pd.DataFrame(columns = ['name','score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts','round_number', 'decision'])\n",
    "strategies = ['AI Basic', 'AI Basic', \"AI 2nd-Gen\", \"AI 2nd-Gen\", \"AI 2nd-Gen\"]\n",
    "winners = []\n",
    "for i in range(0,2000):\n",
    "    game = Game(5)\n",
    "    winner, result = game.play_game()\n",
    "    winners.append(winner)\n",
    "    results2 = results2.append(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "results2.to_csv('Data/gen2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([504, 498, 488, 239, 271])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freqs = Counter(winners)\n",
    "freqs.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.array([239, 271,504, 498, 488])/2000\n",
    "# Make the plot\n",
    "x = [i for i, _ in enumerate(strategies)]\n",
    "plt.bar(x, y, linewidth=3, linestyle=\"--\",\n",
    "         color=\"blue\", alpha = 0.5)\n",
    "plt.xlabel(r\"Strategy\")\n",
    "plt.ylabel(r\"Winning Percentage\")\n",
    "plt.title(r\"Generation 1 Results\")\n",
    "plt.legend(loc=\"lower left\")\n",
    "plt.xticks(x, strategies)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3rd Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "results2 = results2.drop('name', axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict correct move from inputs using logistic regression\n",
    "X_train2, X_test2, y_train2, y_test2 =train_test_split(results2.loc[:, results2.columns != 'decision'], \n",
    "                                                         results2.decision, test_size=0.2, \n",
    "                                                         random_state = 109\n",
    "                                                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=10, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=55,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train2 = y_train2.astype('int')\n",
    "y_test2 = y_test2.astype('int')\n",
    "gen3 = RandomForestClassifier(n_estimators = 55, max_depth = 10, max_features = 'auto') \n",
    "gen3.fit(X_train2, y_train2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Models/gen3']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(gen3,'Models/gen3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "results3 = pd.DataFrame(columns = ['name','score', 'loot', 'num_dangers', 'num_players', 'expected_value', 'leader_score', 'prob_dying', 'extra', 'num_artifacts','round_number', 'decision'])\n",
    "strategies = [\"AI 2nd-Gen\", \"AI 2nd-Gen\", \"AI 3rd-Gen\",\"AI 3rd-Gen\", \"AI 3rd-Gen\"]\n",
    "winners = []\n",
    "for i in range(0,2000):\n",
    "    game = Game(5)\n",
    "    winner, result = game.play_game()\n",
    "    winners.append(winner)\n",
    "    results3 = results3.append(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "results3.to_csv('Data/gen_3.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([398, 453, 415, 362, 372])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freqs = Counter(winners)\n",
    "freqs.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHTlJREFUeJzt3Xu4HFWd7vHvS7hDhEiiAiEEBEFgHMAIAoo6XkAGxTkTBQYUFOVwHEZUOAMODkhGPYKOowgoQaII+oCCSh6MIt7lOkkAgTAEQ+QSg3JJIOEWSHjPH7U2NJveXbVDeu8m+/08Tz+7q2qtqt9qSP961apaJdtERER0ssZwBxAREb0vySIiImolWURERK0ki4iIqJVkERERtZIsIiKiVpJFxCBJekTS1sMdx3CQ9BtJHx7uOGLoJVnEkJN0kKTrJD0q6b7y/qOSNNyx9dfuy9H2hrbnd+FYF0i6V9ISSbd3+lKWdLikFSVxLZH0B0n7r+qYauI9XNKVQ3nMGD5JFjGkJB0LfBX4IvAK4OXAUcBewNpDHMuaQ3m8Bv4fMNH2S4B3A5+V9NoO5a+xvSGwMXAWcKGkjYcgzhiBkixiyEjaCJgCfNT2xbaXunKD7UNsLyvl1pH0JUl3S/qrpG9IWq9se7OkBZKOLb2SeyV9sOUYTeoeL+kvwLckjZF0maT7JS0u78eX8p8D3gicUX7Bn1HWW9I2fW2S9J1S/y5Jn5a0Rtl2uKQrSzyLJf1J0jsH+nxsz+n7DACX1yvrPlfbTwPnAxsA27Z8Fq+XdLWkh0rP480t2w6XNF/S0hLXIWX9ZyRd0FJuYmnvcxKrpFcD3wD2KJ/NQ2X9fpJuLfv9s6Tj6uKPF4ckixhKewDrAJfWlDsVeBWwM7ANsDlwUsv2VwAblfVHAGdKGjOIui8FtgSOpPo38K2yPAF4HDgDwPaJwO+Bo8upp6PbxPq1EsvWwJuADwAfbNm+OzAXGAucBpzb6XSbpLMkPQbcBtwLzBiobEudUeWYTwF3lXWbAz8BPlvaexxwiaRxkjYATgfeaXs0sCdwY91xWtn+H6oe4TXls+nr0ZwL/O+y352AXw1mv9G7kixiKI0FHrC9vG9Fyy/fxyXtXb5IPwJ8wvYi20uBzwMHteznKWCK7adszwAeAbZrWPdp4GTby2w/bvtB25fYfqyU/xzVl36t8iV9IPCp0ku6E/hP4P0txe6yfY7tFcB5wKZUp97asv1RYDRVj+aHwLKBygKvL7/onwC+BBxq+76y7VBghu0Ztp+2fQUwC9iv5XPYSdJ6tu+1PadJmxt4CthB0ktsL7Z9/SrabwyzJIsYSg8CY1tPadjes/wqfZDq/8dxwPrA7JJEHgJ+VtY/s5/WhAM8BmzYsO79tp/oW5C0vqSzyymkJcDvgI1LIqgzlmqc5a6WdXdR9Wb6/KWlrY+Vtxt22qntFbavBMYD/6dD0WvLZzcGmE6VYPpsCby373Mon8UbgE1tP0qV5I4C7pX0E0nbd4ppEP6RKiHdJem3kvZYRfuNYZZkEUPpGqpfygd0KPMA1amgHW1vXF4blYHcOk3q9p9m+VhgO2D3MrC8d1mvAcr3P95TVF/MfSYAf24QaxNr0mzM4hHgo8D7Je1SVt8DnN/yOWxsewPbXyh1Lrf9dqqezm3AOaXeo1QJt88rOh26TSwzbR8AvAz4MfD9uvjjxSHJIoaM7YeAU4CzJE2WtKGkNSTtTDU42zdYew7wX5JeBtX5d0n7NNj/ytQdTZVgHpL0UuDkftv/SjUe0e54K6i+DD8nabSkLYFPAhe0K9+JpJepuqR4Q0mjSswH0/Ccv+0HgW/y7PjMBcC7JO1T9rduGeAfL+nlkt5dxi6WUZ3GW1Hq3QjsLWmCqgsSPtXhsH8Fxktau7RhbUmHSNrI9lPAkpb9xotckkUMKdunUX2h/itwH9UXztnA8cDVpdjxwDzg2nJq6BdUv/6bGGzdrwDrUfUSrqU6bdXqq8DkcjXT6W3q/wvVr/H5wJXA94BpDWNtZapTTguAxVRjEB+3XXcxQKuvAPtJeo3te6h6cP8G3E/V0/i/VP/m16DqUS0EFlGN0XwUoIxtXATcBMwGLutwvF8Bc4C/SHqgrHs/cGf57I+iGjuJ1YDy8KOIiKiTnkVERNRKsoiIiFpJFhERUSvJIiIiavXaRGorbezYsZ44ceJwhxER8aIye/bsB2yPqyu32iSLiRMnMmvWrOEOIyLiRUXSXfWlchoqIiIaSLKIiIhaSRYREVErySIiImolWURERK0ki4iIqJVkERERtZIsIiKiVpJFRETUWm3u4I6IwfvMZ4Y7glVndWpLL0rPIiIiaiVZRERErSSLiIiolWQRERG1kiwiIqJWkkVERNRKsoiIiFpJFhERUSvJIiIiaiVZRERErSSLiIiolWQRERG1kiwiIqJWkkVERNRKsoiIiFpJFhERUSsPP4qIEWl1eljSULQlPYuIiKiVZBEREbWSLCIiolZXk4WkfSXNlTRP0glttn9S0q2SbpL0S0lbtmw7TNIfy+uwbsYZERGddS1ZSBoFnAm8E9gBOFjSDv2K3QBMsv0a4GLgtFL3pcDJwO7AbsDJksZ0K9aIiOismz2L3YB5tufbfhK4EDigtYDtX9t+rCxeC4wv7/cBrrC9yPZi4Apg3y7GGhERHXQzWWwO3NOyvKCsG8gRwE8HU1fSkZJmSZp1//33v8BwIyJiIN28z0Jt1rltQelQYBLwpsHUtT0VmAowadKktvuO6CTX2kc0082exQJgi5bl8cDC/oUkvQ04EXi37WWDqRsREUOjm8liJrCtpK0krQ0cBExvLSBpF+BsqkRxX8umy4F3SBpTBrbfUdZFRMQw6NppKNvLJR1N9SU/Cphme46kKcAs29OBLwIbAj+QBHC37XfbXiTpP6gSDsAU24u6FWtERHTW1bmhbM8AZvRbd1LL+7d1qDsNmNa96CIioqncwR0REbWSLCIiolaSRURE1EqyiIiIWkkWERFRK8kiIiJqJVlEREStPIM7Vqs5hVantkT0kvQsIiKiVpJFRETUSrKIiIhaGbMoVpdz3atLOyKit6RnERERtZIsIiKiVpJFRETUSrKIiIhaSRYREVErySIiImolWURERK1GyULSGyR9sLwfJ2mr7oYVERG9pDZZSDoZOB74VFm1FnBBN4OKiIje0qRn8Q/Au4FHAWwvBEZ3M6iIiOgtTZLFk7YNGEDSBt0NKSIiek2TZPF9SWcDG0v6CPAL4JzuhhUREb2kdiJB21+S9HZgCbAdcJLtK7oeWURE9IxGs86W5JAEERExQtUmC0lLKeMVLR4GZgHH2p7fjcAiIqJ3NOlZfBlYCHwPEHAQ8ApgLjANeHO3gouIiN7QZIB7X9tn215qe4ntqcB+ti8CxnQ5voiI6AFNksXTkt4naY3yel/Ltv6npyIiYjXUJFkcArwfuA/4a3l/qKT1gKO7GFtERPSIJpfOzgfeNcDmK1dtOBER0YuaXA21LnAEsCOwbt962x/qYlwREdFDmpyGOp/q6qd9gN8C44Gl3QwqIiJ6S5NksY3tfwcetX0e8PfA33Q3rIiI6CVNksVT5e9DknYCNgImdi2iiIjoOU2SxVRJY4BPA9OBW4FTm+xc0r6S5kqaJ+mENtv3lnS9pOWSJvfbtkLSjeU1vcnxIiKiO5rcwf1L24uB3wFbAzR5Up6kUcCZwNuBBcBMSdNt39pS7G7gcOC4Nrt43PbODeKLiIgua9KzuKTNuosb1NsNmGd7vu0ngQuBA1oL2L7T9k3A0w32FxERw2TAnoWk7akul91I0v9q2fQSWi6h7WBz4J6W5QXA7oOIbV1Js4DlwBds/3gQdSMiYhXqdBpqO2B/YGOee1PeUuAjDfatNusGMz3IBNsLJW0N/ErSzbbveM4BpCOBIwEmTJgwiF1HRMRgDJgsbF8KXCppD9vXrMS+FwBbtCyPp5q9tpHyrG9sz5f0G2AX4I5+ZaYCUwEmTZqUeaoiIrqkyQD3PEn/RnW57DPlG9zBPRPYtgyG/5lqavN/ahJUufrqMdvLJI0F9gJOa1I3IiJWvSbJ4lLg91TP3l7RdMe2l0s6GrgcGAVMsz1H0hRglu3pkl4H/IhqqvN3STrF9o7Aq4GzJT1NNQj/hX5XUUVExBBqkizWt338yuzc9gxgRr91J7W8n0l1eqp/vavJXeIRET2jyaWzl0nar+uRREREz2qSLI6hShhPSFoiaamkJd0OLCIiekeT51mMHopAIiKid9X2LFQ5VNK/l+UtJO3W/dAiIqJXNDkNdRawB89e9voI1ZxPERExQjS5Gmp327tKugHA9mJJa3c5roiI6CGNnmdRZpA1gKRxZOK/iIgRpUmyOJ3qxrmXSfoccCXw+a5GFRERPaXJ1VDflTQbeCvV5IDvsf0/XY8sIiJ6Rm2ykPR6YI7tM8vyaEm7276u69FFRERPaHIa6utUV0D1ebSsi4iIEaJJspDtZ6b/tv00za6iioiI1USTZDFf0sckrVVexwDzux1YRET0jibJ4ihgT6pnUvQ9GvXIbgYVERG9pePppHJ/xSG2DxqieCIiogd17FnYXgEcMESxREREj2oyUH2VpDOAi6iuhALA9vVdiyoiInpKk2SxZ/k7pWWdgb9b9eFEREQvanIH91uGIpCIiOhdTZ5n8XJJ50r6aVneQdIR3Q8tIiJ6RZNLZ78NXA5sVpZvBz7erYAiIqL3NEkWY21/nzItue3lwIquRhURET2lSbJ4VNImPPs8i9cDD3c1qoiI6ClNroY6FpgOvFLSVcA4YHJXo4qIiJ7S5Gqo2ZLeBGxH9TyLubaf6npkERHRMwY8DSVpW0mXSroFOB94yPYtSRQRESNPpzGLacBlwD8C1wNfG5KIIiKi53Q6DTXa9jnl/RclZXqPiIgRqlOyWFfSLlTjFADrtS5nbqiIiJGjU7K4F/hyy/JfWpYzN1RExAgyYLLInFAREdGnyU15ERExwiVZRERErSSLiIioVXsHt6Rd26x+GLirTCoYERGruSZzQ50F7ArcRHXZ7E7l/SaSjrL98y7GFxERPaDJaag7gV1sT7L9WmAX4BbgbcBpXYwtIiJ6RJNksb3tOX0Ltm+lSh7z6ypK2lfSXEnzJJ3QZvvekq6XtFzS5H7bDpP0x/I6rEljIiKiO5qchpor6evAhWX5QOB2SesAA04qKGkUcCbwdmABMFPS9JJs+twNHA4c16/uS4GTgUlUNwDOLnUXN2pVRESsUk16FocD86gepfoJYH5Z9xTQ6ca93YB5tufbfpIq2RzQWsD2nbZvojyFr8U+wBW2F5UEcQWwb4NYIyKiC5o8z+Jx4D/Lq79HOlTdHLinZXkBsHvDuNrV3bx/IUlHAkcCTJgwoeGuIyJisGp7FpL2knSFpNslze97Ndi32qxzw7ga1bU9tQy8Txo3blzDXUdExGA1GbM4l+r002xgxSD2vQDYomV5PLBwEHXf3K/ubwZx7IiIWIWajFk8bPuntu+z/WDfq0G9mcC2kraStDZwENWzvJu4HHiHpDGSxgDvKOsiImIYNOlZ/FrSF4EfAsv6VtY9z8L2cklHU33JjwKm2Z4jaQowy/Z0Sa8DfgSMAd4l6RTbO9peJOk/qBIOwBTbiwbfvIiIWBWaJIu+QelJLesaPc/C9gxgRr91J7W8n0l1iqld3WlUj3aNiIhh1uRqqDzXIiJihBswWUg61PYFkj7ZbrvtL7dbHxERq59OPYsNyt/RQxFIRET0rk6PVT27/D1l6MKJiIhe1OR5FuOAjwATW8vb/lD3woqIiF7S5GqoS4HfA79gcDflRUTEaqJJsljf9vFdjyQiInpWkzu4L5O0X9cjiYiIntUkWRxDlTAel7RE0lJJS7odWERE9I4mN+Xl0tmIiBGuyZgFkjYHtuS5V0P9rltBRUREb2ly6eypVI9SvZVnr4YykGQRETFCNOlZvAfYzvay2pIREbFaajLAPR9Yq9uBRERE72rSs3gMuFHSL3nu8yw+1rWoIiKipzRJFtNp/oS7iIhYDTW5dPa8oQgkIiJ6V6fnWXzf9vsk3Ux19dNz2H5NVyOLiIie0alncUz5u/9QBBIREb2rU7I4UNJVwA22lw9VQBER0Xs6JYvxwFeB7SXdBFwNXAVcY3vRUAQXERG9odOT8o4DkLQ2MAnYE/gQcI6kh2zvMDQhRkTEcGty6ex6wEuAjcprIXBzN4OKiIje0ulqqKnAjsBS4Dqq01Bftr14iGKLiIge0Wm6jwnAOsBfgD8DC4CHhiKoiIjoLZ3GLPaVJKrexZ7AscBOkhZRDXKfPEQxRkTEMOs4ZmHbwC2SHgIeLq/9gd2AJIuIiBGi05jFx6h6FHsBT1EumwWmkQHuiIgRpVPPYiJwMfAJ2/cOTTgREdGLOo1ZfHIoA4mIiN7V5OFHERExwiVZRERErSSLiIiolWQRERG1kiwiIqJWkkVERNRKsoiIiFpdTRaS9pU0V9I8SSe02b6OpIvK9uskTSzrJ0p6XNKN5fWNbsYZERGdNXmexUqRNAo4E3g71Yy1MyVNt31rS7EjgMW2t5F0EHAqcGDZdoftnbsVX0RENNfNnsVuwDzb820/CVwIHNCvzAHAeeX9xcBby0y3ERHRQ7qZLDYH7mlZXlDWtS1jeznVrLablG1bSbpB0m8lvbHdASQdKWmWpFn333//qo0+IiKe0c1k0a6H4IZl7gUm2N4F+CTwPUkveV5Be6rtSbYnjRs37gUHHBER7XUzWSwAtmhZHk/1/O62ZSStSfWM70W2l9l+EMD2bOAO4FVdjDUiIjroZrKYCWwraStJawMHAdP7lZkOHFbeTwZ+ZduSxpUBciRtDWwLzO9irBER0UHXroayvVzS0cDlwChgmu05kqYAs2xPB84Fzpc0D1hElVAA9gamSFoOrACOsr2oW7FGRERnXUsWALZnADP6rTup5f0TwHvb1LsEuKSbsUVERHO5gzsiImolWURERK0ki4iIqJVkERERtZIsIiKiVpJFRETUSrKIiIhaSRYREVErySIiImolWURERK0ki4iIqJVkERERtZIsIiKiVpJFRETUSrKIiIhaSRYREVErySIiImolWURERK0ki4iIqJVkERERtZIsIiKiVpJFRETUSrKIiIhaSRYREVErySIiImolWURERK0ki4iIqJVkERERtZIsIiKiVpJFRETUSrKIiIhaSRYREVErySIiImolWURERK0ki4iIqJVkERERtZIsIiKiVleThaR9Jc2VNE/SCW22ryPporL9OkkTW7Z9qqyfK2mfbsYZERGddS1ZSBoFnAm8E9gBOFjSDv2KHQEstr0N8F/AqaXuDsBBwI7AvsBZZX8RETEMutmz2A2YZ3u+7SeBC4ED+pU5ADivvL8YeKsklfUX2l5m+0/AvLK/iIgYBrLdnR1Lk4F9bX+4LL8f2N320S1lbillFpTlO4Ddgc8A19q+oKw/F/ip7Yv7HeNI4MiyuB0wtyuNWXXGAg8MdxDDZCS3HUZ2+0dy26H327+l7XF1hdbsYgBqs65/ZhqoTJO62J4KTB18aMND0izbk4Y7juEwktsOI7v9I7ntsPq0v5unoRYAW7QsjwcWDlRG0prARsCihnUjImKIdDNZzAS2lbSVpLWpBqyn9yszHTisvJ8M/MrVebHpwEHlaqmtgG2B/+5irBER0UHXTkPZXi7paOByYBQwzfYcSVOAWbanA+cC50uaR9WjOKjUnSPp+8CtwHLgn22v6FasQ+hFc8qsC0Zy22Fkt38ktx1Wk/Z3bYA7IiJWH7mDOyIiaiVZRERErSQLQNI/SLKk7VvWTSz3gfQvu7OkayTNkXSTpANX4nh3Sho7wLZ9Jf23pNsk3VimQ5kw2GMMMp60v3n7t5Q0u8Q2R9JRDY/xZkmXDbBtTUmfl/THst8bJZ248i0anJHc/pHc9sFKsqgcDFxJGWCv8RjwAdt9U5F8RdLGqyIISTsBXwMOs7297Z2B7wITV8X+O0j7m7f/XmDPEtvuwAmSNutfaJDT03wW2Az4m7LfNwJrDaL+CzWS2z+S2z44tkf0C9gQ+DPwKuC2lvUTgVsa1P8DsG15fydwCnA9cDOwfVm/CfBz4AbgbOAuYGybfZ0PfLDDsV4J/AyYDfy+Zf/fBk4HrgbmA5PT/u63v7TrbmCzsvwIMAW4DngDVTK9jerL6HTgsjb7WB94EBjd4TiHUl06fmP5/Ea1HO9z5b/BtcDLh/L//xd7+0dy21fmlZ4FvAf4me3bgUWSdm1aUdJuwNrAHS2rH7C9K/B14Liy7mTgStu7UN1DMtBplR2pvmgHMhX4F9uvLfs+q2XbplT/k+4PfKFpG0j7B91+SVtIugm4BzjVdt8NoxtQfcnsDswCzgHeRfVr8RUD7G4b4G7bSwc41quBA4G9XP3yXAEc0nK8a23/LfA74CO1rX2+kdz+kdz2QUuyqLqhF5b3F5blWpI25dlfwk+3bPph+TubZ0+f7A1cAGD7J8DiBvvfpJy/vF3ScZI2BPYEfiCp71fGpi1Vfmz7adu3Ai9v0oYi7R9k+23fY/s1VP/YD5PUd7wVwCXl/fbAn2z/0dVPwQuaBCPpg6Xd90jaAngr8FpgZmn3W4GtS/Engb5z4a2f92CM5PaP5LYPWjfnhup5kjYB/g7YSZKpbh60pH+tqfcS4CfAp21f22/zsvJ3Bc/9fJ93Q4ukf+bZXwT7AXOAXYE/2H4Q2FnScVTd5TWAh8ovjHaWtbxvN7dWu3ak/SvR/j62F0qaQ/Xr8WLgCT/35tG2NzFJupwqoc0CPgZMkDTa9lLb3wK+VQZYR5W2nGf7U2129VT5MoLnf961RnL7R3LbV9ZI71lMBr5je0vbE21vAfyJ6nRGW6qmLvlRqfeDhsf5HaX7KOmdwBgA22fa3rm8FgKnASeW7mef9UvZJcCfJL237EeS/nYwjW0j7R98+8dLWq+8HwPsRfvZjm8DtpL0yrL8zK9W2/uUNn/Y9mNUMxmcIWndst9RVKf3AH4JTJb0srLtpZK2fAFtbjWS2z+S275SRnqyOJjqi6/VJcA/dajzPqrTKofr2UvdBvq12+cUYG9J1wPvoBoYex7bNwPHAN9RdenoVcCrge+VIocAR0j6A9Wv8P7PBxmstH/w7X81cF2J4bfAl0rcz2H7Carp838i6UqqQf2BnEh1pc0tkm6gGrw/D1hYTqt9Gvi5qnPlV/Dc028vxEhu/0hu+0rJdB8REVFrpPcsIiKigSSLiIiolWQRERG1kiwiIqJWkkVERNRKsohoQ9KJenZm3Rsl7S7p45LWX4l9Ha42E85FvJgkWUT0I2kPqjmmdi1TO7yNai6gj1NuEmxTp9NMo4dTzSwa8aKVZBHxfJtSTYi4DMD2A1R3/G4G/FrSrwEkPSJpiqTrgD0knSRppqRbJE0td5lPBiYB3y09lPUkvVbSb1U9G+FyVfNsIel1pSdzjaQvlmkfkPT71hsfJV0l6TVD+onEiJdkEfF8Pwe2UDWJ4VmS3mT7dGAh8Bbbbynlnplp1PaVwBm2X2d7J2A9YH/bF1PNA3RImddqOdUzOya7mj13GtVU0wDfAo6yvQfVfD99vknVO0HSq4B1bN/UveZHPF+SRUQ/th+hmu3zSOB+4CJJh7cp2jrTKMBbJF0n6WaqSep2bFNnO2An4ApVM4l+Ghiv6gFSo21fXcp9r6XOD4D9Ja0FfIjq+R0RQ2pEzzobMZAyg+hvgN+UL//D2hR7ZqbRMhHcWcAk2/dI+gywbps6AuaU3sOzK6uJ6QaK5TFJV1DNhfU+qtNaEUMqPYuIfiRtJ2nbllU7U00GtxQYPUC1vsTwgKpnb0xu2dZaby4wrgyiI2ktSTvaXgwslfT6Uq7/Yz6/SfXEtZm2F61MuyJeiPQsIp5vQ+Br5dTQcmAe1Smpg4GfSrq3ZdwCANsPSTqH6nGydwIzWzZ/G/iGpMeBPagSyemSNqL6N/gVqll0jwDOkfQoVa/m4Zb9z5a0hGpcI2LIZdbZiB4hacMyXoKkE4BNbR9TljejSiDb+7lPJowYEjkNFdE7/r5cXnsL1RPYPgsg6QPAdcCJSRQxXNKziIiIWulZRERErSSLiIiolWQRERG1kiwiIqJWkkVERNT6/1CyBqYc9UJAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.array([362, 372,398, 453, 415])/2000\n",
    "# Make the plot\n",
    "x = [i for i, _ in enumerate(strategies)]\n",
    "plt.bar(x, y, linewidth=3, linestyle=\"--\",\n",
    "         color=\"blue\", alpha = 0.5)\n",
    "plt.xlabel(r\"Strategy\")\n",
    "plt.ylabel(r\"Winning Percentage\")\n",
    "plt.title(r\"Generation 3 Results\")\n",
    "plt.xticks(x, strategies)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4th Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}