lab6/lab_6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HyBHi8H-_Nll"
   },
   "source": [
    "# Podejmowanie decyzji\n",
    "\n",
    "## Wstęp\n",
    "\n",
    "Celem tego laboratorium jest zapoznanie się z kilkoma metodami wykorzystywanymi do podejmowania decyzji\n",
    "w kontekście, w którym dwa podmioty mają sprzeczne cele, a konkretnie w sytuacji, w której wygrana jednego\n",
    "podmiotu oznacza przegraną drugiego podmiotu. Wykorzystamy do tego grę w kółko i krzyżyk, która posiada\n",
    "bardzo proste zasady. Zaprezentowane metody mają jednak znacznie szersze zastosowanie i mogą być wykorzystywane\n",
    "w szerokim spektrum problemów decyzyjnych.\n",
    "\n",
    "Zastosowane metody to:\n",
    "* losowe przeszukiwanie przestrzeni decyzji,\n",
    "* heurystyczne przeszukiwanie przestrzeni decyzji,\n",
    "* algorytm minimax,\n",
    "* algorytm alpha-beta,\n",
    "* przeszukiwanie w oparciu o metodę Monte Carlo.\n",
    "\n",
    "Na końcu laboratorium zrobimy turniej graczy zaimplementowanych z użyciem tych metod i zobaczymy, która\n",
    "metoda razi sobie najlepiej w grze w kółko i krzyżyk."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U5dPgzQCVNco"
   },
   "source": [
    "**NIE WYKONANIE TURNIEJU SKUTKUJE OTRZYMANIEM ZERA PUNKTÓW ZA ZADANIE**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VC7kUZoV-Mmv"
   },
   "source": [
    "# Gra w kółko i krzyżyk\n",
    "\n",
    "Zaczniemy od implementacji gry w kółko i krzyżyk. Możemy podejść do tego na kilka różnych sposobów. Jednym z najprostszych jest gracz wykonujący losowy ruch i liczący na szczęście. Trochę bardziej skomplikowanym graczem będzie gracz wykorzystujący jakąś heurystykę (można taką znaleźć na Wikipedii), nas będą bardziej interesowali gracze oparci o przeszukiwanie drzewa rozgrywki np. algorytmem minimax czy A*, a w bardziej skomplikowanych problemach znajdują zastosowanie również algorytmy probabilistyczne typu Monte Carlo, a w prostych - klasyczne grafowe przeszukiwanie.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "roh7tiIlARnf"
   },
   "source": [
    "Na początek zaiplemętujemy samą planszę i metody niezbędne do rozgrywki takie jak sprawdzenie, czy ktoś wygrał, wyświetlające stan planszy itd. Poniżej znajduje się implementacja gry, która wyświetla stan gry w fomie tekstowej oraz informuje, kto wygrał grę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "tKivv0kMflUd"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numba import njit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-07T15:46:44.169680Z",
     "start_time": "2022-11-07T15:46:44.140069Z"
    },
    "id": "EdN6KydUAf3N"
   },
   "outputs": [],
   "source": [
    "PLAYER_1 = -1\n",
    "PLAYER_2 = 1\n",
    "STRIKE = 3 # same as SIZE, difrent require changes check_for_end() and consequent\n",
    "SIZE = 3 # same as STRIKE\n",
    "\n",
    "KERNEL_D1 = np.eye(STRIKE)\n",
    "KERNEL_D2 = np.rot90(np.eye(STRIKE))\n",
    "\n",
    "\n",
    "class TicTacToe:\n",
    "    def __init__(self, player1, player2, size):\n",
    "        self.size = size\n",
    "        self.board = np.zeros((size, size), dtype=int)\n",
    "        self.player1 = player1\n",
    "        self.player2 = player2\n",
    "        self.chars = {0: \" \", PLAYER_1: \"O\", PLAYER_2: \"X\"}\n",
    "\n",
    "    def play(self, verbose=True):\n",
    "        self.print_board(verbose)\n",
    "        for _ in range((self.size*self.size)//2):\n",
    "            self.player1.move(self.board, PLAYER_1)\n",
    "            self.print_board(verbose)\n",
    "            if check_for_end(self.board, PLAYER_1):\n",
    "                if verbose:\n",
    "                    print(\"player 1 wins\")\n",
    "                return \"win\"\n",
    "            self.player2.move(self.board, PLAYER_2)\n",
    "            self.print_board(verbose)\n",
    "            if check_for_end(self.board, PLAYER_2):\n",
    "                if verbose:\n",
    "                    print(\"player 2 wins\")\n",
    "                return \"loss\"\n",
    "\n",
    "        if (self.size % 2) == 1:\n",
    "            self.player1.move(self.board, PLAYER_1)\n",
    "            self.print_board(verbose)\n",
    "            if check_for_end(self.board, PLAYER_1):\n",
    "                if verbose:\n",
    "                    print(\"player 1 wins\")\n",
    "                return \"win\"\n",
    "            else:\n",
    "                if verbose:\n",
    "                    print(\"draw\")\n",
    "                return \"draw\"\n",
    "            \n",
    "        else:\n",
    "            if verbose:\n",
    "                    print(\"draw\")\n",
    "            return \"draw\"\n",
    "\n",
    "\n",
    "    def print_board(self, verbose):\n",
    "        if not verbose:\n",
    "            return\n",
    "        str_line = \"---------------\"\n",
    "        print(\"\\n\" + str_line)\n",
    "        for row in self.board:\n",
    "            for cell in row:\n",
    "                symbol = self.chars[cell]\n",
    "                print(f\"| {symbol} |\", end=\"\")\n",
    "            print(\"\\n\" + str_line)\n",
    "\n",
    "@njit()\n",
    "def check_for_end(board, player):\n",
    "    return (\n",
    "        check_rows(board, player)\n",
    "        or check_cols(board, player)\n",
    "        or check_diagonals(board, player)\n",
    "    )\n",
    "\n",
    "@njit()\n",
    "def check_rows(board, player):\n",
    "    conv = board.sum(axis=0)\n",
    "    return (np.max(conv * player) )>=STRIKE\n",
    "\n",
    "@njit()\n",
    "def check_cols(board, player):\n",
    "    conv = board.sum(axis=1)\n",
    "    return (np.max(conv * player))>=STRIKE\n",
    "\n",
    "@njit()\n",
    "def check_diagonals(board, player):\n",
    "    conv = np.multiply(board,KERNEL_D1).sum()\n",
    "    conv2 = np.multiply(board, KERNEL_D2).sum()\n",
    "    return (conv* player)>=STRIKE or (conv2* player) >=STRIKE\n",
    "\n",
    "@njit()\n",
    "def can_make_move( board, row, col):\n",
    "    return board[row][col] == 0\n",
    "\n",
    "@njit()\n",
    "def get_possible_moves( board):\n",
    "    res = []\n",
    "    for j, row in enumerate(board):\n",
    "        for i, _ in enumerate(row):\n",
    "            if can_make_move(board, j, i):\n",
    "                res.append((j, i))\n",
    "\n",
    "    return res\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LG3l858uNpxe"
   },
   "source": [
    "## Interfejs gracza\n",
    "\n",
    "\n",
    "Skoro mamy już zdefiniowaną grę to teraz potrzebny jest nam gracz. Poniżej zdefiniowany jest interface PlayerInreface. Należy go wykorzystywać implementując swoich graczy. Interfejs ma metodę `move`, która reprezentuje  pojedynczy ruch gracza a także metodę `name`, która zwraca nazwę zaimplementowanego algorytmu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:47:39.708616Z",
     "start_time": "2022-11-08T12:47:39.697099Z"
    },
    "id": "9jjdHPZTJT04"
   },
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "\n",
    "class PlayerInterface(ABC):\n",
    "    @abstractmethod\n",
    "    def move(self, board, player):\n",
    "        pass\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return type(self).__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J42IHI35OpJI"
   },
   "source": [
    "Zobaczmy, jak wyglądałby prawdopodobnie najprostszy gracz do zaimplementowania, a więc gracz losowy. Wybiera on losowo wiersz i kolumnę, a następnie sprawdza, czy pole jest puste. Jeżeli tak, to stawia tam swój znak."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:48:27.405379Z",
     "start_time": "2022-11-08T12:48:27.392789Z"
    },
    "id": "MZj-A7-VKeX7"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "class RandomPlayer(PlayerInterface):\n",
    "    def move(self, board, player):\n",
    "        while True:\n",
    "            row, col = random.choice(get_possible_moves(board))\n",
    "            board[row][col] = player\n",
    "            return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LdJ3LAc2PGqE"
   },
   "source": [
    "Sprawdźmy, czy wszystko działa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:48:42.288896Z",
     "start_time": "2022-11-08T12:48:42.275525Z"
    },
    "id": "tpmJkAoqJNos"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "| X || X ||   |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "player 2 wins\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'loss'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game = TicTacToe(RandomPlayer(), RandomPlayer(),SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y3jmIj-MPSpe"
   },
   "source": [
    "Napiszemy teraz kilku kolejnych graczy, podejmujących decyzje nieco inteligentniej, a na koniec zrobimy mały turniej i sprawdzimy, który jest najlepszy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XswYIAZOPzT-"
   },
   "source": [
    "# Podejmowanie decyzji oparte o heurystykę\n",
    "\n",
    "W każdym nowym problemie warto sprawdzić proste podejście heurystyczne, wykorzystujące elementarną wiedzę o problemie. Sama gra w kółko i krzyżyk, jak wiadomo, nie jest zbyt skomplikowana. Jest w niej najwyżej 9 możliwych ruchów, mniej niż $3^9 - 1$ możliwych końcowych stanów planszy, a naiwnie licząc, grę można rozegrać na $9!$ sposobów. Dzięki tam mocnemu uproszczeniu istnieje tu strategia optymalna, gwarantująca w najgorszym wypadku remis:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cwayvozxWmAW"
   },
   "source": [
    "Dla tej gry istnieje [optymalna startegia](https://en.wikipedia.org/wiki/Tic-tac-toe#Strategy) tzn. w najgorszym przypadku zremisujemy.\n",
    "\n",
    "1. Win: If the player has two in a row, they can place a third to get three in a row.\n",
    "2. Block: If the opponent has two in a row, the player must play the third themselves to block the opponent.\n",
    "3. Fork: Cause a scenario where the player has two ways to win (two non-blocked lines of 2).\n",
    "4. Blocking an opponent's fork: If there is only one possible fork for the opponent, the player should block it. Otherwise, the player should block all forks in any way that simultaneously allows them to make two in a row. Otherwise, the player should make a two in a row to force the opponent into defending, as long as it does not result in them producing a fork. For example, if \"X\" has two opposite corners and \"O\" has the center, \"O\" must not play a corner move to win. (Playing a corner move in this scenario produces a fork for \"X\" to win.)\n",
    "5. Center: A player marks the center. (If it is the first move of the game, playing a corner move gives the second player more opportunities to make a mistake and may therefore be the better choice; however, it makes no difference between perfect players.)\n",
    "6. Opposite corner: If the opponent is in the corner, the player plays the opposite corner.\n",
    "7. Empty corner: The player plays in a corner square.\n",
    "8. Empty side: The player plays in a middle square on any of the four sides.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C6vDkBNIWnL-"
   },
   "source": [
    "Implementacja takiego bota byłaby jednak niezbyt ciekawa, a na dodatek specyficzna tylko dla tego konkretnego problemu. Dlatego my zajmiemy się eksploracją drzewa gry, a więc możliwych stanów oraz przejść między nimi. Na dobry początek ulepszymy naszego losowego bota trywialną heurystyką - jeżeli to możliwe, ma wybrać ruch wygrywający, a jeżeli nie, to losowy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pyf6g0Yk_Nl0"
   },
   "source": [
    "Można by też zadać pytanie, czemu nie wykorzystamy tutaj ciekawszego problemu, jak np. szachy. Odpowiedź jest prosta - nie mamy na to czasu, a konkretnie wieczności. Shannon obliczył dolną granicę złożoności drzewa gry na $10^{120}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vTFRQSKP_Nl1"
   },
   "source": [
    "## Wygraj, jeśli to możliwe w kolejnym kroku"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YGzaz4P8HEt2"
   },
   "source": [
    "### Zadanie 1 (0.5 punkt)  \n",
    "\n",
    "Zaimplementuj ulepszonego losowego bota tak, aby wybierał ruch wygrywający, jeżeli to możliwe, a jeżeli nie, to losowy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:52:07.330742Z",
     "start_time": "2022-11-08T12:52:07.322516Z"
    },
    "id": "jzvSXtGQNmm5"
   },
   "outputs": [],
   "source": [
    "class RandomPlayerWinIfCan(PlayerInterface):\n",
    "    def move(self, board, player):\n",
    "        # winning move\n",
    "        for row, col in get_possible_moves(board):              \n",
    "            board[row][col] = player\n",
    "            \n",
    "            if check_for_end(board, player):\n",
    "                    return\n",
    "       \n",
    "            board[row][col] = 0\n",
    "\n",
    "        # random move\n",
    "        while True:\n",
    "            row, col = random.choice(get_possible_moves(board))\n",
    "            board[row][col] = player\n",
    "            return\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "FV4COOFCfwm-"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O || O |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || X || X |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O || O |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   || X || X |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "| O || O || O |\n",
      "---------------\n",
      "player 1 wins\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'win'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game = TicTacToe(RandomPlayerWinIfCan(), RandomPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n_9YHPHnhzsu"
   },
   "source": [
    "## Blokuj kolejny krok wygrywający przeciwnika\n",
    "\n",
    "Skoro w poprzednim zadaniu wygrywamy, kiedy możemy to zrobić w jednym kroku, to spróbujmy ulepszyć naszą strategię wcześniej. Możemy to zrobić, minimalizując swoje straty, czyli sprawdzamy dodatkowo, czy przeciwnik może skończyć grę. Jeżeli tak, to go blokujemy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VHNF5ladHIeW"
   },
   "source": [
    "### Zadanie 2 (0.5 punkt)  \n",
    "\n",
    "Zaimplementuj ulepszenie bota, w którym dodatkowo jeżeli nie możemy wygrać w danym ruchu, a przeciwnik tak, to go blokujemy. A jeżeli ani my, ani przeciwnik nie może wygrać w kolejnym ruchu, to wykonujemy losowe posunięcie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-07T15:57:48.581936Z",
     "start_time": "2022-11-07T15:57:48.568842Z"
    },
    "id": "8PDreIKxhzM1"
   },
   "outputs": [],
   "source": [
    "class BlockingPlayer(PlayerInterface):\n",
    "    def move(self, board, player):\n",
    "        # winning move\n",
    "        for row, col in get_possible_moves(board):              \n",
    "            board[row][col] = player\n",
    "            \n",
    "            if check_for_end(board, player):\n",
    "                    return\n",
    "       \n",
    "            board[row][col] = 0\n",
    "        \n",
    "        # block\n",
    "        for row, col in get_possible_moves(board):              \n",
    "            board[row][col] = -player\n",
    "            \n",
    "            if check_for_end(board, -player):\n",
    "                board[row][col] = player\n",
    "                return\n",
    "                    \n",
    "            board[row][col] = 0\n",
    "        \n",
    "        # random move\n",
    "        while True:\n",
    "            row, col = random.choice(get_possible_moves(board))\n",
    "            board[row][col] = player\n",
    "            return\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "4WcJ9OcvjyDP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "player 1 wins\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'win'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game = TicTacToe(BlockingPlayer(), RandomPlayerWinIfCan(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yWzDAt-rkdzG"
   },
   "source": [
    "# Algorytm minimax\n",
    "\n",
    "Zaiplemetujemy teraz algorytm minimax. Minimalizuje on nasze maksymalne straty lub maksymalizuje minimalne zyski (maksmin). Poprzednie 2 kroki nas do tego zbliżały. Algorytm wywodzi się z teorii gier o sumie zerowej (gdzie wygrana ma wartość 1, przegrana -1, a remis 0 - w takich grach wygrana jednego gracza, oznacza, że drugi gracz przegrał, czyli nie ma strategii, która prowadziłaby do sytuacji *win-win*).\n",
    "\n",
    "**Twierdzenie o minimaksie (minimax theorem)** mówi, że dla każdej gry dwuosobowej gry o sumie zerowej istnieje wartość V i mieszana strategia dla każdego gracza, takie, że:\n",
    "\n",
    "* biorąc pod uwagę strategię gracza drugiego, najlepszą możliwą spłatą dla gracza pierwszego jest V,\n",
    "* biorąc pod uwagę strategię gracza pierwszego, najlepszą możliwą spłatą dla gracza drugiego jest -V.\n",
    "\n",
    "\n",
    "Każdy gracz minimalizuje maksymalną możliwą spłatę dla swojego przeciwnika – ponieważ gra jest grą o sumie zerowej, wynikiem tego algorytmu jest również maksymalizowanie swojej minimalnej spłaty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VD2j-ZOUcj1D"
   },
   "source": [
    "![obraz.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "enBwAeNS_Nl6"
   },
   "source": [
    "Powyższa ilustracja przedstawia fragment analizy końcowej partii gry w kółko i krzyżyk. **Max** oznacza turę,\n",
    "w której gracz wybiera ten spośród dostępnych ruchów, który da maksymalną spłatę, natomiast **min** oznacza turę,\n",
    "w której gracz wybiera ruch, który da minimalną spłatę. Inaczej - *max* to ruch, z punktu wiedzenia gracza,\n",
    "dla którego chcemy, żeby wygrał, a *min* ruch gracza, który chcemy żeby przegrał.\n",
    "\n",
    "Minimax jest algorytem rekurencyjnym, w którym liście drzewa możliwych ruchów\n",
    "oznaczają zakończenie gry, z przypisaną do nich wartością z punktu wiedzenia gracza, którego ruch jest w korzeniu\n",
    "drzewa możliwych ruchów. We wcześniejszych węzłach - w zależności czy jest tura gracza max, czy min, będą wybierane te gałęzie, które maksymalizują, bądź minimalizują wartość spłaty.\n",
    "\n",
    "Przykładowo - w pierwszym wierszu mamy trzy strzałki i gracza *max*, dlatego gracz ten wybierze pierwszy\n",
    "możliwy ruch, bo daje on maksymalną spłatę. W drugim wierwszu w środkowej kolumnie mamy dwie strzałki.\n",
    "Gracz *min* wybierze zatem strzałkę (ruch) prawy, ponieważ minimalizuje on spłatę (0).\n",
    "Analogicznie w drugim wierszu po prawej stronie wybierana jest prawa strzałka,\n",
    "ponieważ daje ona wartość mimalną (-1).\n",
    "\n",
    "Poniższy diagram zawiera to samo drzewo analizy ruchów, gdzie pozostawiono wyłącznie wartości spłaty dla\n",
    "poszczególnych węzłów."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EhcLPgilck3K"
   },
   "source": [
    "![obraz.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e8jeFFz5pniS"
   },
   "source": [
    "Algorytm *minimax* jest następujący:\n",
    "1. zainicalizuj wartość na $-\\infty$ dla gracza którego spłata jest maksymalizowana\n",
    "  i na $+\\infty$ dla gracza którego spłata jest minimalizowana,\n",
    "2. sprawdź czy gra się nie skończyła, jeżeli tak to ewaluuj stan gry z punktu widzenia gracza maksymalizującego i zwróć wynik,\n",
    "3. dla każdego możliwego ruchu każdego z graczy wywołaj rekurencyjnie *minimax*:\n",
    "  1. przy maksymalizacji wyniku, zwiększ wynik, jeśli otrzymany wynik jest większy od dotychczas największego wyniku,\n",
    "  2. przy minimalizacji wyniku, pomniejsz wynik, jeśli otrzymany wynik jest mniejszy od dotychczas najmniejszego wyniku,\n",
    "  3. zwróć najlepszy wynik.\n",
    "\n",
    "Algorytm ten wymaga dodatkowo funkcji ewaluującej, która oceni stan gry na końcu. Uznajemy, że zwycięstwo to +1, przegrana -1, a remis 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2VgIulyIHRYn"
   },
   "source": [
    "## Zadanie 3 (2 punkty)  \n",
    "\n",
    " Zaimplementuj gracza realizującego algorytm minimaks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T12:56:05.603012Z",
     "start_time": "2022-11-08T12:56:05.576605Z"
    },
    "id": "8mpF72tLkdR-"
   },
   "outputs": [],
   "source": [
    "class MinimaxPlayer(PlayerInterface):\n",
    "    def move(self, board, player):\n",
    "        if not board.any():\n",
    "            # empty board - playing in the center\n",
    "            board[1][1] = player\n",
    "            return\n",
    "\n",
    "        _, best_move = self.minimax(board, player, True)\n",
    "        board[best_move[0]][best_move[1]] = player\n",
    "\n",
    "    def minimax(self, board, player, maximize):\n",
    "        possible_moves = get_possible_moves(board)\n",
    "\n",
    "        # end condition\n",
    "        if len(possible_moves) == 0 or check_for_end(board, player) or check_for_end(board, -player):\n",
    "            if maximize:\n",
    "                return self.evaluate(board, player), None\n",
    "            else:\n",
    "                return self.evaluate(board, -player), None\n",
    "\n",
    "        best_move = None\n",
    "        best_score = -float('inf') if maximize else float('inf')\n",
    "\n",
    "        for move in possible_moves:\n",
    "            # move to the position and call minimax recursively\n",
    "            board[move[0]][move[1]] = player\n",
    "            score, _ = self.minimax(board, -player, not maximize)\n",
    "            \n",
    "            # clear the move\n",
    "            board[move[0]][move[1]] = 0\n",
    "\n",
    "            if maximize:\n",
    "                # max\n",
    "                if score > best_score:\n",
    "                    best_score = score\n",
    "                    best_move = move\n",
    "            else:\n",
    "                # min\n",
    "                if score < best_score:\n",
    "                    best_score = score\n",
    "                    best_move = move\n",
    "\n",
    "        return best_score, best_move\n",
    "\n",
    "    def evaluate(self, board, player):\n",
    "        if check_for_end(board, player):\n",
    "            return 1\n",
    "        if check_for_end(board, -player):\n",
    "            return -1\n",
    "        if len(get_possible_moves(board)) == 0:\n",
    "            return 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "iwrRdk8DRbFP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "| O || O ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "draw\n",
      "CPU times: total: 15.6 ms\n",
      "Wall time: 35.6 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'draw'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(MinimaxPlayer(), BlockingPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tIylZm4rYfsI"
   },
   "source": [
    "Wróć na chwilę do implementacji minimaxu i zastanów się, co się dzieje, jeżeli ten algorytm wykonuje ruch na pustej planszy i jak to wpływa na jego czas działania. Może coś można poprawić?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n5sntoLbaKhT"
   },
   "source": [
    "# Alpha-beta pruning\n",
    "\n",
    "Widzimy, że nasz poprzedni gracz jest właściwie idealny, bo w końcu sprawdza całe drzewo gry. Ma tylko w związku z tym wadę - dla większości problemów wykonuje się wieczność. Dlatego też zastosujemy ważne ulepszenie algorytmu minimax, nazywane alfa-beta pruning.\n",
    "\n",
    "W przypadku klasycznego minimaxu ewaluujemy każdą możliwą ścieżkę gry. Alfa-beta pruning, jak i wiele innych metod, opiera się na \"przycinaniu\" drzewa, czyli nie ewaluujemy tych odnóg drzewa, co do których wiemy, że nie da ona lepszego wyniku niż najlepszy obecny. W niektórych wypadkach, np. w dobrej implementacji dla szachów, potrafi zredukować liczbę rozważanych ścieżek nawet o 99.8%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U1_6NI9-s3DM"
   },
   "source": [
    "Do poprzedniego algorytmu dodajemy 2 zmienne, $\\alpha$ i $\\beta$:\n",
    "\n",
    "* $\\alpha$ przechowuje najlepszą wartość dla gracza maksymalizującego swój wynik,\n",
    "* $\\beta$ przechowuje najlepszą wartość dla gracza minimalizującego swój wynik.\n",
    "\n",
    "Dzięki tej informacji możemy przerwać sprawdzanie danej gałęzi, kiedy $\\alpha$ jest większa od $\\beta$. Oznacza to bowiem sytuację, w której najlepszy wynik gracza maksymalizującego jest większy niż najlepszy wynik gracza minimalizującego."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lJ7JYyxRw6VN"
   },
   "source": [
    "![obraz.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZRwWeM94gPs7"
   },
   "source": [
    "Pseudokod:\n",
    "\n",
    "\n",
    "```\n",
    "function alphabeta(node, depth, α, β, maximizingPlayer) is\n",
    "    if depth = 0 or node is a terminal node then\n",
    "        return the heuristic value of node\n",
    "    if maximizingPlayer then\n",
    "        value := −∞\n",
    "        for each child of node do\n",
    "            value := max(value, alphabeta(child, depth − 1, α, β, FALSE))\n",
    "            α := max(α, value)\n",
    "            if α ≥ β then\n",
    "                break (* β cutoff *)\n",
    "            \n",
    "        return value\n",
    "    else\n",
    "        value := +∞\n",
    "        for each child of node do\n",
    "            value := min(value, alphabeta(child, depth − 1, α, β, TRUE))\n",
    "            β := min(β, value)\n",
    "            if α ≥ β then\n",
    "                break (* α cutoff *)\n",
    "        return value\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "--C2n5H6HXmM"
   },
   "source": [
    "## Zadanie 4 (2 punkty)\n",
    "\n",
    "  Zaimplementuj gracza realizującego algorytm alfa-beta pruning, zmodyfikuj funkcje ewaluacji tak by preferowała szybkie zwycięstwo i penalizowała szybką porażkę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T13:04:42.368902Z",
     "start_time": "2022-11-08T13:04:42.353193Z"
    },
    "id": "M0dGwlnFS8hj"
   },
   "outputs": [],
   "source": [
    "class AlphaBetaPlayer(PlayerInterface):\n",
    "    def move(self, board, player):\n",
    "        if not board.any():\n",
    "            # empty board - playing in the center\n",
    "            board[1][1] = player\n",
    "            return\n",
    "\n",
    "        _, best_move = self.alphabeta(board, player, True, -float('inf'), float('inf'), 0)\n",
    "\n",
    "        board[best_move[0]][best_move[1]] = player\n",
    "\n",
    "    def alphabeta(self, board, player, maximize, alpha, beta, depth):\n",
    "        possible_moves = get_possible_moves(board)\n",
    "\n",
    "        # end condition\n",
    "        if len(possible_moves) == 0 or check_for_end(board, player) or check_for_end(board, -player):\n",
    "            if maximize:\n",
    "                return self.evaluate(board, player, depth), None\n",
    "            else:\n",
    "                return self.evaluate(board, -player, depth), None\n",
    "\n",
    "        best_move = None\n",
    "        best_score = -float('inf') if maximize else float('inf')\n",
    "\n",
    "        for move in possible_moves:\n",
    "            # move to the position and call minimax recursively\n",
    "            board[move[0]][move[1]] = player\n",
    "            score, _ = self.alphabeta(board, -player, not maximize, alpha, beta, depth + 1)\n",
    "            \n",
    "            # clear the move\n",
    "            board[move[0]][move[1]] = 0\n",
    "\n",
    "            if maximize:\n",
    "                # max\n",
    "                if score > best_score:\n",
    "                    best_score = score\n",
    "                    best_move = move\n",
    "                    alpha = max(alpha, best_score)\n",
    "            else:\n",
    "                # min\n",
    "                if score < best_score:\n",
    "                    best_score = score\n",
    "                    best_move = move\n",
    "                    beta = min(beta, best_score)\n",
    "            \n",
    "            # check alpha-beta condition        \n",
    "            if alpha >= beta:\n",
    "                break\n",
    "\n",
    "        return best_score, best_move\n",
    "\n",
    "    def evaluate(self, board, player, depth):\n",
    "        if check_for_end(board, player):\n",
    "            return 1 / depth # prefer fast win\n",
    "        if check_for_end(board, -player):\n",
    "            return -1 / depth #penalize quick loss\n",
    "        if len(get_possible_moves(board)) == 0:\n",
    "            return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "gejqt6hxoGGD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "| O || O ||   |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O ||   |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "|   || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || O || X |\n",
      "---------------\n",
      "| X || X || O |\n",
      "---------------\n",
      "draw\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 314 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'draw'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(AlphaBetaPlayer(), MinimaxPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jywnp22zmd-o"
   },
   "source": [
    "# Monte Carlo Tree Search (MCTS)\n",
    "\n",
    "Metody Monte Carlo polegają na wprowadzeniu losowości i przybliżaniu za jej pomocą rozwiązań dla trudnych problemów. Dla gry w kółko i krzyżyk nie jest to co prawda niezbędne, ale dla bardziej skomplikowanych gier, jak szachy czy go, już zdecydowanie tak.\n",
    "\n",
    "Ogólna metoda MCTS składa się z 4 etapów:\n",
    "* selekcji - wybieramy najlepsze dziecko, aż dotrzemy do liścia,\n",
    "* ekspansji - jeżeli nie możemy dokonać selekcji, rozwijamy drzewo we wszystkich możliwych kierunkach z węzła,\n",
    "* symulacji - po ekspansji wybieramy węzeł do przeprowadzenia symulacji gry aż do końca,\n",
    "* wstecznej propagacji - kiedy dotrzemy do końca, ewaluujemy wynik gry i propagujemy go w górę drzewa.\n",
    "\n",
    "W naszym wypadku wystarczy nieco prostszy algorytm Pure Monte Carlo Tree Search (Pure MCTS), w którym realizujemy tylko symulację i wsteczną propagację. Dla każdego możliwego ruchu w danej rundzie przeprowadzamy N symulacji oraz obliczamy prawdopodobieństwo zwycięstwa/remisu/przegranej dla każdego z możliwych ruchów, a następnie wybieramy najlepszy ruch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ahb1QeIfHcH3"
   },
   "source": [
    "## Zadanie 5 (2 punkty)  \n",
    "\n",
    " Zaimplementuj gracza realizującego algorytm Pure MCTS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-08T13:08:53.710354Z",
     "start_time": "2022-11-08T13:08:53.683363Z"
    },
    "id": "_kixa8QfoPli"
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "class MonteCarloPlayer(PlayerInterface):\n",
    "    def __init__(self):\n",
    "        self.NO_SIMULATIONS = 500\n",
    "    \n",
    "    def move(self, board, player):\n",
    "        best_move = self.pure_mcts(board, player)\n",
    "        board[best_move[0]][best_move[1]] = player\n",
    "    \n",
    "    def pure_mcts(self, board, player):\n",
    "        possible_moves = get_possible_moves(board)\n",
    "        possible_moves_evaluation = {move: None for move in possible_moves}\n",
    "        \n",
    "        for move in possible_moves:\n",
    "            move_results = {'win': 0, 'loss': 0, 'draw': 0}\n",
    "            \n",
    "            # move and simulate\n",
    "            board[move[0]][move[1]] = player\n",
    "            \n",
    "            for _ in range(self.NO_SIMULATIONS):\n",
    "                board_copy = copy.deepcopy(board)\n",
    "                simulation_results = self.simulate(board_copy, -player, player)\n",
    "                move_results[simulation_results] += 1\n",
    "                \n",
    "            # evaluate\n",
    "            evaluation = move_results['win'] / (move_results['win'] + move_results['loss'] +\\\n",
    "                move_results['draw'])\n",
    "            possible_moves_evaluation[move] = evaluation\n",
    "            \n",
    "            # clear move\n",
    "            board[move[0]][move[1]] = 0\n",
    "            \n",
    "        # get best move\n",
    "        return max(possible_moves_evaluation, key=possible_moves_evaluation.get)\n",
    "        \n",
    "    def simulate(self, board, current_player, evaluated_player):\n",
    "        possible_moves = get_possible_moves(board)\n",
    "        \n",
    "        # end conditions\n",
    "        if check_for_end(board, current_player):\n",
    "            return 'win' if current_player == evaluated_player else 'loss'\n",
    "        elif check_for_end(board, -current_player):\n",
    "            return 'win' if current_player != evaluated_player else 'loss'\n",
    "        elif len(possible_moves) == 0:\n",
    "            return 'draw'\n",
    "        \n",
    "        # move    \n",
    "        move = random.choice(possible_moves)\n",
    "        board[move[0]][move[1]] = current_player\n",
    "        \n",
    "        # simulate further\n",
    "        return self.simulate(board, -current_player, evaluated_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "ok8ely0adZNI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "|   ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   ||   |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X ||   || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O ||   ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "|   || O ||   |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "|   || O || O |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || X ||   |\n",
      "---------------\n",
      "\n",
      "---------------\n",
      "| X || O || X |\n",
      "---------------\n",
      "| X || O || O |\n",
      "---------------\n",
      "| O || X || O |\n",
      "---------------\n",
      "draw\n",
      "CPU times: total: 250 ms\n",
      "Wall time: 650 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'draw'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "game = TicTacToe(MonteCarloPlayer(), MinimaxPlayer(), SIZE)\n",
    "game.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wkDVcylKJaTG"
   },
   "source": [
    "# Turniej\n",
    "\n",
    "Teraz przeprowadzimy turniej w celu porównania zaimplementowanych metod. Każdy algorytm będzie grał z każdym po 10 razy.\n",
    "\n",
    "**NIE WYKONANIE TURNIEJU SKUTKUJE OTRZYMANIEM ZERA PUNKTÓW ZA ZADANIE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "id": "aVNaDdwdRhoN"
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "from IPython.display import display\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "def print_scores(scores, names):\n",
    "    win = {}\n",
    "    for name in names:\n",
    "        win[name] = [scores[\"win\"][name][n] for n in names]\n",
    "    loss = {}\n",
    "    for name in names:\n",
    "        loss[name] = [scores[\"loss\"][name][n] for n in names]\n",
    "    draw = {}\n",
    "    for name in names:\n",
    "        draw[name] = [scores[\"draw\"][name][n] for n in names]\n",
    "\n",
    "    df = pd.DataFrame.from_dict(win, orient=\"index\", columns=names)\n",
    "    print('win')\n",
    "    display(df)\n",
    "    \n",
    "    df2 = pd.DataFrame.from_dict(loss, orient=\"index\", columns=names)\n",
    "    display(df2)\n",
    "    print('loss')\n",
    "    \n",
    "    df3 = pd.DataFrame.from_dict(draw, orient=\"index\", columns=names)\n",
    "    display(df3)\n",
    "    print('draw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "id": "Sf8fn_m39nef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "win\n"
     ]
    },
    {
     "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>RandomPlayer</th>\n",
       "      <th>BlockingPlayer</th>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>BlockingPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>9</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>7</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "      <td>10</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      RandomPlayer  BlockingPlayer  RandomPlayerWinIfCan  \\\n",
       "RandomPlayer                     3               1                     2   \n",
       "BlockingPlayer                  10               3                    10   \n",
       "RandomPlayerWinIfCan             9               1                     5   \n",
       "MinimaxPlayer                   10               7                    10   \n",
       "AlphaBetaPlayer                 10               2                     9   \n",
       "MonteCarloPlayer                10               5                     9   \n",
       "\n",
       "                      MinimaxPlayer  AlphaBetaPlayer  MonteCarloPlayer  \n",
       "RandomPlayer                      0                0                 0  \n",
       "BlockingPlayer                    0                0                 9  \n",
       "RandomPlayerWinIfCan              0                0                 3  \n",
       "MinimaxPlayer                     0                0                10  \n",
       "AlphaBetaPlayer                   0                0                10  \n",
       "MonteCarloPlayer                  0                0                10  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>RandomPlayer</th>\n",
       "      <th>BlockingPlayer</th>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>BlockingPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      RandomPlayer  BlockingPlayer  RandomPlayerWinIfCan  \\\n",
       "RandomPlayer                     5               8                     7   \n",
       "BlockingPlayer                   0               2                     0   \n",
       "RandomPlayerWinIfCan             0               6                     4   \n",
       "MinimaxPlayer                    0               0                     0   \n",
       "AlphaBetaPlayer                  0               0                     0   \n",
       "MonteCarloPlayer                 0               0                     0   \n",
       "\n",
       "                      MinimaxPlayer  AlphaBetaPlayer  MonteCarloPlayer  \n",
       "RandomPlayer                      9                9                10  \n",
       "BlockingPlayer                    4                1                 1  \n",
       "RandomPlayerWinIfCan              8                8                 7  \n",
       "MinimaxPlayer                     0                0                 0  \n",
       "AlphaBetaPlayer                   0                0                 0  \n",
       "MonteCarloPlayer                  0                1                 0  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss\n"
     ]
    },
    {
     "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>RandomPlayer</th>\n",
       "      <th>BlockingPlayer</th>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>RandomPlayer</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>BlockingPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomPlayerWinIfCan</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MinimaxPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AlphaBetaPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MonteCarloPlayer</th>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      RandomPlayer  BlockingPlayer  RandomPlayerWinIfCan  \\\n",
       "RandomPlayer                     2               1                     1   \n",
       "BlockingPlayer                   0               5                     0   \n",
       "RandomPlayerWinIfCan             1               3                     1   \n",
       "MinimaxPlayer                    0               3                     0   \n",
       "AlphaBetaPlayer                  0               8                     1   \n",
       "MonteCarloPlayer                 0               5                     1   \n",
       "\n",
       "                      MinimaxPlayer  AlphaBetaPlayer  MonteCarloPlayer  \n",
       "RandomPlayer                      1                1                 0  \n",
       "BlockingPlayer                    6                9                 0  \n",
       "RandomPlayerWinIfCan              2                2                 0  \n",
       "MinimaxPlayer                    10               10                 0  \n",
       "AlphaBetaPlayer                  10               10                 0  \n",
       "MonteCarloPlayer                 10                9                 0  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "draw\n",
      "CPU times: total: 36.1 s\n",
      "Wall time: 54.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "number_of_rounds = 10\n",
    "players = [\n",
    "    RandomPlayer(),\n",
    "    BlockingPlayer(),\n",
    "    RandomPlayerWinIfCan(),\n",
    "    MinimaxPlayer(),\n",
    "    AlphaBetaPlayer(),\n",
    "    MonteCarloPlayer(),\n",
    "]\n",
    "scores = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))\n",
    "\n",
    "for player in players:\n",
    "    for adversary in players:\n",
    "        for i in range(number_of_rounds):\n",
    "            game = TicTacToe(player, adversary, SIZE)\n",
    "            score = game.play(False)\n",
    "            # print(\"player name {} adversary name {} score {} \".format(player.name, adversary.name, score))\n",
    "            scores[score][player.name][adversary.name] += 1\n",
    "\n",
    "\n",
    "print_scores(scores, [player.name for player in players])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yiPBrh4AdmgC"
   },
   "source": [
    "# Zadanie dodatkowe (2 punkty)\n",
    "\n",
    "Rozwiń kod algorytmu MCTS tak, aby działał z ogólnymi zasadami, a nie w formie uproszczonego Pure MCTS.\n",
    "\n",
    "Zastosuj prosty, ale bardzo skuteczny sposób selekcji UCT (*Upper Confidence Bound 1 applied to trees*), będący wariantem bardzo skutecznych metod UCB, stosowanych m.in. w podejmowaniu decyzji, uczeniu ze wzmocnieniem i systemach rekomendacyjnych. Polega na wyborze tego węzła, dla którego następujące wyrażenie ma maksymalną wartość:\n",
    "\n",
    "$$\n",
    "\\large\n",
    "\\frac{w_i}{n_i} + c\\sqrt\\frac{\\ln N_i}{n_i}\n",
    "$$\n",
    "\n",
    "gdzie:\n",
    "* $w_i$ to liczba zwycięstw dla węzła po rozważeniu $i$-tego ruchu\n",
    "* $n_i$ to łączna liczba symulacji przeprowadzonych dla węzła po $i$-tym ruchu,\n",
    "* $N_i$ oznacza całkowitą liczbę symulacji przeprowadzoną po $i$-tym ruchu dla węzła-rodzica aktualnie rozważanego węzła,\n",
    "* $c$ to hiperparametr, wedle teorii powinien mieć wartość $\\sqrt{2}$.\n",
    "\n",
    "O uzasadnieniu tego wzoru możesz więcej przeczytać [tutaj](https://en.wikipedia.org/wiki/Monte_Carlo_tree_search#Exploration_and_exploitation).\n",
    "\n",
    "Jeżeli chcesz, możesz zastosować ten algorytm dla bardziej skomplikowanej gry, jak np. warcaby czy szachy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nCIck2r0_NmD"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}