Added a greedy policy

This commit is contained in:
Philipp committed 2023-02-17 03:04:19 +01:00
1 parent ef20f3f68a
commit dfe3b3aa59
1 file changed
+140 -421
+140 -421
View File
@@ -85,7 +85,7 @@
},
{
"cell_type": "code",
"execution_count": 1,
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
@@ -126,7 +126,7 @@
},
{
"cell_type": "code",
"execution_count": 2,
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
@@ -135,14 +135,10 @@
"import abc\n",
"from typing import Final\n",
"from scipy.ndimage import binary_dilation\n",
"import matplotlib.pyplot as plt\n",
"from abc import ABC\n",
"from tqdm.notebook import tqdm\n",
"import plotly.graph_objects as go\n",
"from plotly.subplots import make_subplots\n",
"from scipy.spatial import Delaunay\n",
"from KDEpy import FFTKDE\n",
"from ipywidgets import widgets"
"from ipywidgets import interact\n",
"import matplotlib.pyplot as plt"
]
},
{
@@ -156,7 +152,7 @@
},
{
"cell_type": "code",
"execution_count": 3,
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
@@ -180,27 +176,9 @@
},
{
"cell_type": "code",
"execution_count": 4,
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[-1, -1],\n",
" [-1, 0],\n",
" [-1, 1],\n",
" [ 0, -1],\n",
" [ 0, 1],\n",
" [ 1, -1],\n",
" [ 1, 0],\n",
" [ 1, 1]])"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"DIRECTIONS: Final[np.ndarray] = np.array(\n",
" [[i, j] for i in range(-1, 2) for j in range(-1, 2) if j != 0 or i != 0],\n",
@@ -219,21 +197,9 @@
},
{
"cell_type": "code",
"execution_count": 5,
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[-1, 1],\n",
" [ 1, -1]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"START_SQUARE: Final[np.ndarray] = np.array(\n",
" [[ENEMY, PLAYER], [PLAYER, ENEMY]], dtype=int\n",
@@ -254,27 +220,9 @@
},
{
"cell_type": "code",
"execution_count": 6,
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, -1, 1, 0, 0, 0],\n",
" [ 0, 0, 0, 1, -1, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"def get_new_games(number_of_games: int) -> np.ndarray:\n",
" \"\"\"Generates a stack of initialised game boards.\n",
@@ -295,7 +243,7 @@
},
{
"cell_type": "code",
"execution_count": 7,
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
@@ -340,22 +288,11 @@
},
{
"cell_type": "code",
"execution_count": 8,
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 300x300 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def plot_othello_board(board, ax=None) -> None:\n",
"def plot_othello_board(board: np.ndarray, ax=None) -> None:\n",
" \"\"\"Plots a single otello board.\n",
"\n",
" If a matplot axis object is given the board will be plotted into that axis. If not an axis object will be generated.\n",
@@ -400,7 +337,7 @@
},
{
"cell_type": "code",
"execution_count": 9,
"execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
@@ -430,7 +367,7 @@
},
{
"cell_type": "code",
"execution_count": 10,
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
@@ -467,24 +404,11 @@
},
{
"cell_type": "code",
"execution_count": 11,
"execution_count": 37,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"array([[[1, 1, 1],\n",
" [1, 0, 1],\n",
" [1, 1, 1]]])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"SURROUNDING: Final = np.array(\n",
" [[[1, 1, 1], [1, 0, 1], [1, 1, 1]]]\n",
@@ -494,35 +418,9 @@
},
{
"cell_type": "code",
"execution_count": 12,
"execution_count": 38,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"9.11 ms ± 144 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
"920 ms ± 10.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
},
{
"data": {
"text/plain": [
"array([[[False, False, False, False, False, False, False, False],\n",
" [False, False, False, False, False, False, False, False],\n",
" [False, False, False, True, False, False, False, False],\n",
" [False, False, True, False, False, False, False, False],\n",
" [False, False, False, False, False, True, False, False],\n",
" [False, False, False, False, True, False, False, False],\n",
" [False, False, False, False, False, False, False, False],\n",
" [False, False, False, False, False, False, False, False]]])"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"def _recursive_steps(\n",
" board: np.ndarray,\n",
@@ -555,7 +453,7 @@
" return step_one\n",
"\n",
"\n",
"def get_possible_turns(boards: np.ndarray) -> np.ndarray:\n",
"def get_possible_turns(boards: np.ndarray, tqdm_on: bool = False) -> np.ndarray:\n",
" \"\"\"Analyses a stack of boards.\n",
"\n",
" Args:\n",
@@ -574,11 +472,14 @@
" _poss_turns &= binary_dilation(\n",
" boards == -1, SURROUNDING\n",
" ) # checks where fields are next to an enemy filed an empty\n",
" for game, idx, idy in itertools.product(\n",
" iterate_over = itertools.product(\n",
" range(boards.shape[0]), range(BOARD_SIZE), range(BOARD_SIZE)\n",
" ):\n",
" position = idx, idy\n",
" )\n",
" if tqdm_on:\n",
" iterate_over = tqdm(iterate_over, total=np.prod(boards.shape))\n",
" for game, idx, idy in iterate_over:\n",
" if _poss_turns[game, idx, idy]:\n",
" position = idx, idy\n",
" _poss_turns[game, idx, idy] = any(\n",
" _recursive_steps(boards[game, :, :], direction, position) > 0\n",
" for direction in DIRECTIONS\n",
@@ -612,7 +513,7 @@
},
{
"cell_type": "code",
"execution_count": 13,
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -647,7 +548,7 @@
},
{
"cell_type": "code",
"execution_count": 14,
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -716,19 +617,9 @@
},
{
"cell_type": "code",
"execution_count": 15,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"191 µs ± 2.27 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n",
"33 µs ± 1.4 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n",
"33.8 µs ± 345 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n"
]
}
],
"outputs": [],
"source": [
"def final_boards_evaluation(boards: np.ndarray) -> np.ndarray:\n",
" \"\"\"Evaluates the board at the end of the game.\n",
@@ -796,7 +687,7 @@
},
{
"cell_type": "code",
"execution_count": 16,
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -808,27 +699,9 @@
},
{
"cell_type": "code",
"execution_count": 17,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"89.6 ms ± 3.13 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
},
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 300x300 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def do_moves(boards: np.ndarray, moves: np.ndarray) -> np.ndarray:\n",
" \"\"\"Executes a single move on a stack o Othello boards.\n",
@@ -928,7 +801,7 @@
},
{
"cell_type": "code",
"execution_count": 18,
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -1022,7 +895,7 @@
},
{
"cell_type": "code",
"execution_count": 19,
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
@@ -1031,7 +904,7 @@
" A policy playing a random turn by setting epsilon to 0.\n",
" \"\"\"\n",
"\n",
" def __init__(self, epsilon: float):\n",
" def __init__(self, epsilon: float = 0):\n",
" _ = epsilon\n",
" super().__init__(epsilon=0)\n",
"\n",
@@ -1051,6 +924,42 @@
"assert np.any((5 >= rnd_policy_result) & (rnd_policy_result >= 3))"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"class GreedyPolicy(GamePolicy):\n",
" \"\"\"\n",
" A policy playing always one of the strongest turns.\n",
" \"\"\"\n",
"\n",
" def __init__(self, epsilon: float = 1):\n",
" _ = epsilon\n",
" super().__init__(1)\n",
"\n",
" @property\n",
" def policy_name(self) -> str:\n",
" return \"greedy_policy\"\n",
"\n",
" def _internal_policy(self, boards: np.ndarray) -> np.ndarray:\n",
" policies = np.random.rand(*boards.shape)\n",
" for game, idx, idy in itertools.product(\n",
" range(boards.shape[0]), range(BOARD_SIZE), range(BOARD_SIZE)\n",
" ):\n",
"\n",
" if _poss_turns[game, idx, idy]:\n",
" position = idx, idy\n",
" policies[game, idx, idy] += np.sum(\n",
" _recursive_steps(boards[game, :, :], direction, position)\n",
" for direction in DIRECTIONS\n",
" )\n",
" return policies"
],
"metadata": {
"collapsed": false
}
},
{
"cell_type": "markdown",
"metadata": {},
@@ -1070,28 +979,9 @@
},
{
"cell_type": "code",
"execution_count": 20,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.03 s ± 19 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
"990 ms ± 29.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
},
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 1200x600 with 8 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def single_turn(\n",
" current_boards: np, policy: GamePolicy\n",
@@ -1139,37 +1029,29 @@
},
{
"cell_type": "code",
"execution_count": 21,
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 1200x4800 with 61 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def simulate_game(\n",
" nr_of_games: int, policies: tuple[GamePolicy, GamePolicy], tqdm_on: bool = False\n",
" nr_of_games: int,\n",
" policies: tuple[GamePolicy, GamePolicy],\n",
" tqdm_on: bool = False,\n",
") -> tuple[np.ndarray, np.ndarray]:\n",
" \"\"\"Simulates a stack of games.\n",
"\n",
" Args:\n",
" nr_of_games: The number of games that should be simulated.\n",
" policies: The policies that should be used to simulate the game.\n",
" tqdm_on: Switches tqdm on.\n",
"\n",
" Returns:\n",
" A stack of board histories and actions.\n",
" \"\"\"\n",
" board_history_stack = np.zeros((SIMULATE_TURNS, nr_of_games, 8, 8), dtype=int)\n",
" action_history_stack = np.zeros((SIMULATE_TURNS, nr_of_games, 2), dtype=int)\n",
" board_history_stack = np.zeros((SIMULATE_TURNS, nr_of_games, 8, 8), dtype=np.int8)\n",
" action_history_stack = np.zeros((SIMULATE_TURNS, nr_of_games, 2), dtype=np.int8)\n",
" current_boards = get_new_games(nr_of_games)\n",
" for turn_index in tqdm(range(SIMULATE_TURNS)) if tqdm_on else range(SIMULATE_TURNS):\n",
" policy_index = turn_index % 2\n",
@@ -1194,17 +1076,9 @@
},
{
"cell_type": "code",
"execution_count": 22,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"9.48 s ± 330 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
"outputs": [],
"source": [
"%timeit simulate_game(100, (RandomPolicy(1), RandomPolicy(1)))"
]
@@ -1226,25 +1100,16 @@
},
{
"cell_type": "code",
"execution_count": 23,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(70, 100, 8, 8)\n",
"(70, 100, 2)\n"
]
}
],
"outputs": [],
"source": [
"if not os.path.exists(\"rnd_history.npy\") and not os.path.exists(\"rnd_action.npy\"):\n",
" rnds = RandomPolicy(1), RandomPolicy(1)\n",
" simulation_results = simulate_game(100, rnds, tqdm_on=True)\n",
" simulation_results = simulate_game(10_000, rnds, tqdm_on=True)\n",
" _board_history, _action_history = simulation_results\n",
" np.save(\"rnd_history.npy\", _board_history)\n",
" np.save(\"rnd_action.npy\", _action_history)\n",
" np.save(\"rnd_history.npy\", np.astpye.astype(np.int8))\n",
" np.save(\"rnd_action.npy\", _action_history.astype(np.int8))\n",
"else:\n",
" _board_history = np.load(\"rnd_history.npy\")\n",
" _action_history = np.load(\"rnd_action.npy\")\n",
@@ -1253,19 +1118,17 @@
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(70, 100, 8, 8)\n",
"(70, 100, 2)\n"
]
"cell_type": "markdown",
"source": [],
"metadata": {
"collapsed": false
}
],
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(_board_history.shape)\n",
"print(_action_history.shape)"
@@ -1273,116 +1136,55 @@
},
{
"cell_type": "code",
"execution_count": 113,
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(70, 100)"
]
},
"execution_count": 113,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"__board_history = _board_history.copy()\n",
"__board_history[1::2] = __board_history[1::2] * -1\n",
"poss_turn = np.sum(\n",
" get_possible_turns(__board_history.reshape((-1, 8, 8))).reshape(70, -1, 8, 8),\n",
" axis=(2, 3),\n",
")\n",
"if not os.path.exists(\"turn_possible.npy\"):\n",
" __board_history = _board_history.copy()\n",
" __board_history[1::2] = __board_history[1::2] * -1\n",
"\n",
" _poss_turns = get_possible_turns(\n",
" __board_history.reshape((-1, 8, 8)), tqdm_on=True\n",
" ).reshape((70, -1, 8, 8))\n",
" np.save(_poss_turns, \"turn_possible.npy\")\n",
" del __board_history\n",
"_poss_turns = np.load(\"turn_possible.npy\")\n",
"poss_turn = np.sum(_poss_turns, axis=(2, 3))\n",
"poss_turn.shape"
]
},
{
"cell_type": "code",
"execution_count": 122,
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"mean_possiblilites = np.mean(poss_turn, axis=1)\n",
"mean_possibilities = np.mean(poss_turn, axis=1)\n",
"plt.title(\n",
" f\"Mean turn possible per turn {np.prod(np.extract(mean_possiblilites, mean_possiblilites))}\"\n",
" f\"Mean turn possible per turn {np.prod(np.extract(mean_possibilities, mean_possibilities))}\"\n",
")\n",
"plt.plot(mean_possiblilites)\n",
"plt.show()"
"plt.plot(mean_possibilities)\n",
"plt.show()\n",
"del mean_possibilities"
]
},
{
"cell_type": "code",
"execution_count": 114,
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "bcb93d3e5e0b4c5ea594ad05ce99838d",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"interactive(children=(IntSlider(value=35, description='turn', max=70), Output()), _dom_classes=('widget-intera…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"@interact(turn=(0, 70))\n",
"@interact(turn=(0, 69))\n",
"def poss_turn_count(turn):\n",
" plt.hist(poss_turn[turn])"
]
},
{
"cell_type": "code",
"execution_count": 52,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(70, 100)\n"
]
},
{
"data": {
"text/plain": [
"array([[ 0.046875, 0.046875, 0.046875, ..., 0.046875, 0.046875,\n",
" 0.046875],\n",
" [-0.046875, -0.046875, -0.046875, ..., -0.046875, -0.046875,\n",
" -0.046875],\n",
" [ 0.046875, 0.046875, 0.046875, ..., 0.046875, 0.046875,\n",
" 0.046875],\n",
" ...,\n",
" [ 0. , 0. , 0. , ..., 0. , 0. ,\n",
" 0. ],\n",
" [ 0. , 0. , 0. , ..., 0. , 0. ,\n",
" 0. ],\n",
" [ 0. , 0. , 0. , ..., 0. , 0. ,\n",
" 0. ]])"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"def calculate_direct_score(board_history: np.ndarray) -> np.ndarray:\n",
" boards_evaluated = np.reshape(\n",
@@ -1401,30 +1203,11 @@
},
{
"cell_type": "code",
"execution_count": 62,
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "36fb809b8d9e42b79512d6d788b2008f",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"interactive(children=(IntSlider(value=35, description='turn', max=70), Output()), _dom_classes=('widget-intera…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"from ipywidgets import interact\n",
"import matplotlib.pyplot as plt\n",
"\n",
"\n",
"@interact(turn=(0, 70))\n",
"@interact(turn=(0, 69))\n",
"def hist_direct_score(turn):\n",
" score_history = calculate_direct_score(_board_history) * 64\n",
" score_history[1::2] = score_history[1::2] * -1\n",
@@ -1436,27 +1219,9 @@
},
{
"cell_type": "code",
"execution_count": 63,
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(100,)\n"
]
},
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def calculate_final_evaluation_for_history(board_history: np.ndarray) -> np.ndarray:\n",
" final_evaluation = final_boards_evaluation(board_history[-1])\n",
@@ -1473,20 +1238,9 @@
},
{
"cell_type": "code",
"execution_count": 68,
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def calculate_who_won(board_history: np.ndarray) -> np.ndarray:\n",
" who_won = evaluate_who_won(board_history[-1])\n",
@@ -1500,22 +1254,11 @@
},
{
"cell_type": "code",
"execution_count": 82,
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"outputs": [],
"source": [
"def history_changed(board_history: np.ndarray) -> np.ndarray:\n",
" return ~np.all(\n",
@@ -1531,20 +1274,9 @@
},
{
"cell_type": "code",
"execution_count": 125,
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(70, 100)"
]
},
"execution_count": 125,
"metadata": {},
"output_type": "execute_result"
}
],
"outputs": [],
"source": [
"def get_gamma_table(board_history, gamma_value: float):\n",
" unchanged = history_changed(board_history)\n",
@@ -1558,22 +1290,9 @@
},
{
"cell_type": "code",
"execution_count": 126,
"execution_count": null,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'calulate_fina_score' is not defined",
"output_type": "error",
"traceback": [
"\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
"\u001B[1;31mNameError\u001B[0m Traceback (most recent call last)",
"Cell \u001B[1;32mIn[126], line 25\u001B[0m\n\u001B[0;32m 20\u001B[0m combined_score[turn \u001B[38;5;241m-\u001B[39m \u001B[38;5;241m1\u001B[39m] \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m values\n\u001B[0;32m 22\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m combined_score\n\u001B[1;32m---> 25\u001B[0m np\u001B[38;5;241m.\u001B[39mmax(\u001B[43mcalculate_q_reword\u001B[49m\u001B[43m(\u001B[49m\u001B[43m_board_history\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgamma\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m0.8\u001B[39;49m\u001B[43m)\u001B[49m, axis\u001B[38;5;241m=\u001B[39m\u001B[38;5;241m1\u001B[39m)\n",
"Cell \u001B[1;32mIn[126], line 16\u001B[0m, in \u001B[0;36mcalculate_q_reword\u001B[1;34m(board_history, who_won_fraction, final_score_fraction, gamma)\u001B[0m\n\u001B[0;32m 12\u001B[0m combined_score \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39mzeros_like(gama_table)\n\u001B[0;32m 13\u001B[0m combined_score \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m calculate_direct_score(board_history) \u001B[38;5;241m*\u001B[39m (\n\u001B[0;32m 14\u001B[0m \u001B[38;5;241m1\u001B[39m \u001B[38;5;241m-\u001B[39m who_won_fraction \u001B[38;5;241m+\u001B[39m final_score_fraction\n\u001B[0;32m 15\u001B[0m )\n\u001B[1;32m---> 16\u001B[0m combined_score[\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m] \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[43mcalulate_fina_score\u001B[49m(board_history) \u001B[38;5;241m*\u001B[39m final_score_fraction\n\u001B[0;32m 17\u001B[0m combined_score[\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m] \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m calculate_who_won(board_history) \u001B[38;5;241m*\u001B[39m who_won_fraction\n\u001B[0;32m 18\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m turn \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mrange\u001B[39m(SIMULATE_TURNS \u001B[38;5;241m-\u001B[39m \u001B[38;5;241m1\u001B[39m , \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m, \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m):\n",
"\u001B[1;31mNameError\u001B[0m: name 'calulate_fina_score' is not defined"
]
}
],
"outputs": [],
"source": [
"def calculate_q_reword(\n",
" board_history: np.ndarray,\n",
@@ -1590,7 +1309,7 @@
" combined_score += calculate_direct_score(board_history) * (\n",
" 1 - who_won_fraction + final_score_fraction\n",
" )\n",
" combined_score[-1] += calulate_fina_score(board_history) * final_score_fraction\n",
" combined_score[-1] += calulate_final_score(board_history) * final_score_fraction\n",
" combined_score[-1] += calculate_who_won(board_history) * who_won_fraction\n",
" for turn in range(SIMULATE_TURNS - 1, -1, -1):\n",
" values = gama_table[turn] * combined_score[turn]\n",