class CSP(search.Problem):\n",
+ " """This class describes finite-domain Constraint Satisfaction Problems.\n",
+ " A CSP is specified by the following inputs:\n",
+ " variables A list of variables; each is atomic (e.g. int or string).\n",
+ " domains A dict of {var:[possible_value, ...]} entries.\n",
+ " neighbors A dict of {var:[var,...]} that for each variable lists\n",
+ " the other variables that participate in constraints.\n",
+ " constraints A function f(A, a, B, b) that returns true if neighbors\n",
+ " A, B satisfy the constraint when they have values A=a, B=b\n",
+ "\n",
+ " In the textbook and in most mathematical definitions, the\n",
+ " constraints are specified as explicit pairs of allowable values,\n",
+ " but the formulation here is easier to express and more compact for\n",
+ " most cases. (For example, the n-Queens problem can be represented\n",
+ " in O(n) space using this notation, instead of O(N^4) for the\n",
+ " explicit representation.) In terms of describing the CSP as a\n",
+ " problem, that's all there is.\n",
+ "\n",
+ " However, the class also supports data structures and methods that help you\n",
+ " solve CSPs by calling a search function on the CSP. Methods and slots are\n",
+ " as follows, where the argument 'a' represents an assignment, which is a\n",
+ " dict of {var:val} entries:\n",
+ " assign(var, val, a) Assign a[var] = val; do other bookkeeping\n",
+ " unassign(var, a) Do del a[var], plus other bookkeeping\n",
+ " nconflicts(var, val, a) Return the number of other variables that\n",
+ " conflict with var=val\n",
+ " curr_domains[var] Slot: remaining consistent values for var\n",
+ " Used by constraint propagation routines.\n",
+ " The following methods are used only by graph_search and tree_search:\n",
+ " actions(state) Return a list of actions\n",
+ " result(state, action) Return a successor of state\n",
+ " goal_test(state) Return true if all constraints satisfied\n",
+ " The following are just for debugging purposes:\n",
+ " nassigns Slot: tracks the number of assignments made\n",
+ " display(a) Print a human-readable representation\n",
+ " """\n",
+ "\n",
+ " def __init__(self, variables, domains, neighbors, constraints):\n",
+ " """Construct a CSP problem. If variables is empty, it becomes domains.keys()."""\n",
+ " variables = variables or list(domains.keys())\n",
+ " self.variables = variables\n",
+ " self.domains = domains\n",
+ " self.neighbors = neighbors\n",
+ " self.constraints = constraints\n",
+ " self.initial = ()\n",
+ " self.curr_domains = None\n",
+ " self.nassigns = 0\n",
+ "\n",
+ " def assign(self, var, val, assignment):\n",
+ " """Add {var: val} to assignment; Discard the old value if any."""\n",
+ " assignment[var] = val\n",
+ " self.nassigns += 1\n",
+ "\n",
+ " def unassign(self, var, assignment):\n",
+ " """Remove {var: val} from assignment.\n",
+ " DO NOT call this if you are changing a variable to a new value;\n",
+ " just call assign for that."""\n",
+ " if var in assignment:\n",
+ " del assignment[var]\n",
+ "\n",
+ " def nconflicts(self, var, val, assignment):\n",
+ " """Return the number of conflicts var=val has with other variables."""\n",
+ "\n",
+ " # Subclasses may implement this more efficiently\n",
+ " def conflict(var2):\n",
+ " return (var2 in assignment and\n",
+ " not self.constraints(var, val, var2, assignment[var2]))\n",
+ "\n",
+ " return count(conflict(v) for v in self.neighbors[var])\n",
+ "\n",
+ " def display(self, assignment):\n",
+ " """Show a human-readable representation of the CSP."""\n",
+ " # Subclasses can print in a prettier way, or display with a GUI\n",
+ " print('CSP:', self, 'with assignment:', assignment)\n",
+ "\n",
+ " # These methods are for the tree and graph-search interface:\n",
+ "\n",
+ " def actions(self, state):\n",
+ " """Return a list of applicable actions: nonconflicting\n",
+ " assignments to an unassigned variable."""\n",
+ " if len(state) == len(self.variables):\n",
+ " return []\n",
+ " else:\n",
+ " assignment = dict(state)\n",
+ " var = first([v for v in self.variables if v not in assignment])\n",
+ " return [(var, val) for val in self.domains[var]\n",
+ " if self.nconflicts(var, val, assignment) == 0]\n",
+ "\n",
+ " def result(self, state, action):\n",
+ " """Perform an action and return the new state."""\n",
+ " (var, val) = action\n",
+ " return state + ((var, val),)\n",
+ "\n",
+ " def goal_test(self, state):\n",
+ " """The goal is to assign all variables, with all constraints satisfied."""\n",
+ " assignment = dict(state)\n",
+ " return (len(assignment) == len(self.variables)\n",
+ " and all(self.nconflicts(variables, assignment[variables], assignment) == 0\n",
+ " for variables in self.variables))\n",
+ "\n",
+ " # These are for constraint propagation\n",
+ "\n",
+ " def support_pruning(self):\n",
+ " """Make sure we can prune values from domains. (We want to pay\n",
+ " for this only if we use it.)"""\n",
+ " if self.curr_domains is None:\n",
+ " self.curr_domains = {v: list(self.domains[v]) for v in self.variables}\n",
+ "\n",
+ " def suppose(self, var, value):\n",
+ " """Start accumulating inferences from assuming var=value."""\n",
+ " self.support_pruning()\n",
+ " removals = [(var, a) for a in self.curr_domains[var] if a != value]\n",
+ " self.curr_domains[var] = [value]\n",
+ " return removals\n",
+ "\n",
+ " def prune(self, var, value, removals):\n",
+ " """Rule out var=value."""\n",
+ " self.curr_domains[var].remove(value)\n",
+ " if removals is not None:\n",
+ " removals.append((var, value))\n",
+ "\n",
+ " def choices(self, var):\n",
+ " """Return all values for var that aren't currently ruled out."""\n",
+ " return (self.curr_domains or self.domains)[var]\n",
+ "\n",
+ " def infer_assignment(self):\n",
+ " """Return the partial assignment implied by the current inferences."""\n",
+ " self.support_pruning()\n",
+ " return {v: self.curr_domains[v][0]\n",
+ " for v in self.variables if 1 == len(self.curr_domains[v])}\n",
+ "\n",
+ " def restore(self, removals):\n",
+ " """Undo a supposition and all inferences from it."""\n",
+ " for B, b in removals:\n",
+ " self.curr_domains[B].append(b)\n",
+ "\n",
+ " # This is for min_conflicts search\n",
+ "\n",
+ " def conflicted_vars(self, current):\n",
+ " """Return a list of variables in current assignment that are in conflict"""\n",
+ " return [var for var in self.variables\n",
+ " if self.nconflicts(var, current[var], current) > 0]\n",
+ "
![](\"images/fig_5_2.png\")
\n",
"\n",
- "The states are represented wih capital letters inside the triangles (eg. \"A\") while moves are the labels on the edges between states (eg. \"a1\"). Terminal nodes carry utility values. Note that the terminal nodes are named in this example 'B1', 'B2' and 'B2' for the nodes below 'B', and so forth.\n",
+ "The states are represented with capital letters inside the triangles (eg. \"A\") while moves are the labels on the edges between states (eg. \"a1\"). Terminal nodes carry utility values. Note that the terminal nodes are named in this example 'B1', 'B2' and 'B2' for the nodes below 'B', and so forth.\n",
"\n",
"We will model the moves, utilities and initial state like this:"
]
@@ -849,6 +856,9 @@
"## alphabeta_player\n",
"The `alphabeta_player`, on the other hand, calls the `alphabeta_search` function, which returns the best move in the current game state. Thus, the `alphabeta_player` always plays the best move given a game state, assuming that the game tree is small enough to search entirely.\n",
"\n",
+ "## minimax_player\n",
+ "The `minimax_player`, on the other hand calls the `minimax_search` function which returns the best move in the current game state.\n",
+ "\n",
"## play_game\n",
"The `play_game` function will be the one that will actually be used to play the game. You pass as arguments to it an instance of the game you want to play and the players you want in this game. Use it to play AI vs AI, AI vs human, or even human vs human matches!"
]
@@ -1651,9 +1661,9 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.5.3"
+ "version": "3.8.2-final"
}
},
"nbformat": 4,
"nbformat_minor": 1
-}
+}
\ No newline at end of file
diff --git a/games.py b/games.py
index 00a2c33d3..d22b2e640 100644
--- a/games.py
+++ b/games.py
@@ -1,18 +1,23 @@
-"""Games, or Adversarial Search (Chapter 5)"""
+"""Games or Adversarial Search (Chapter 5)"""
-from collections import namedtuple
+import copy
+import itertools
import random
+from collections import namedtuple
-from utils import argmax
+import numpy as np
+
+from utils import vector_add
-infinity = float('inf')
GameState = namedtuple('GameState', 'to_move, utility, board, moves')
+StochasticGameState = namedtuple('StochasticGameState', 'to_move, utility, board, moves, chance')
+
# ______________________________________________________________________________
-# Minimax Search
+# MinMax Search
-def minimax_decision(state, game):
+def minmax_decision(state, game):
"""Given a state in a game, calculate the best move by searching
forward all the way to the terminal states. [Figure 5.3]"""
@@ -21,7 +26,7 @@ def minimax_decision(state, game):
def max_value(state):
if game.terminal_test(state):
return game.utility(state, player)
- v = -infinity
+ v = -np.inf
for a in game.actions(state):
v = max(v, min_value(game.result(state, a)))
return v
@@ -29,29 +34,69 @@ def max_value(state):
def min_value(state):
if game.terminal_test(state):
return game.utility(state, player)
- v = infinity
+ v = np.inf
for a in game.actions(state):
v = min(v, max_value(game.result(state, a)))
return v
- # Body of minimax_decision:
- return argmax(game.actions(state),
- key=lambda a: min_value(game.result(state, a)))
+ # Body of minmax_decision:
+ return max(game.actions(state), key=lambda a: min_value(game.result(state, a)))
+
# ______________________________________________________________________________
-def alphabeta_search(state, game):
+def expect_minmax(state, game):
+ """
+ [Figure 5.11]
+ Return the best move for a player after dice are thrown. The game tree
+ includes chance nodes along with min and max nodes.
+ """
+ player = game.to_move(state)
+
+ def max_value(state):
+ v = -np.inf
+ for a in game.actions(state):
+ v = max(v, chance_node(state, a))
+ return v
+
+ def min_value(state):
+ v = np.inf
+ for a in game.actions(state):
+ v = min(v, chance_node(state, a))
+ return v
+
+ def chance_node(state, action):
+ res_state = game.result(state, action)
+ if game.terminal_test(res_state):
+ return game.utility(res_state, player)
+ sum_chances = 0
+ num_chances = len(game.chances(res_state))
+ for chance in game.chances(res_state):
+ res_state = game.outcome(res_state, chance)
+ util = 0
+ if res_state.to_move == player:
+ util = max_value(res_state)
+ else:
+ util = min_value(res_state)
+ sum_chances += util * game.probability(chance)
+ return sum_chances / num_chances
+
+ # Body of expect_minmax:
+ return max(game.actions(state), key=lambda a: chance_node(state, a), default=None)
+
+
+def alpha_beta_search(state, game):
"""Search game to determine best action; use alpha-beta pruning.
As in [Figure 5.7], this version searches all the way to the leaves."""
player = game.to_move(state)
- # Functions used by alphabeta
+ # Functions used by alpha_beta
def max_value(state, alpha, beta):
if game.terminal_test(state):
return game.utility(state, player)
- v = -infinity
+ v = -np.inf
for a in game.actions(state):
v = max(v, min_value(game.result(state, a), alpha, beta))
if v >= beta:
@@ -62,7 +107,7 @@ def max_value(state, alpha, beta):
def min_value(state, alpha, beta):
if game.terminal_test(state):
return game.utility(state, player)
- v = infinity
+ v = np.inf
for a in game.actions(state):
v = min(v, max_value(game.result(state, a), alpha, beta))
if v <= alpha:
@@ -70,9 +115,9 @@ def min_value(state, alpha, beta):
beta = min(beta, v)
return v
- # Body of alphabeta_cutoff_search:
- best_score = -infinity
- beta = infinity
+ # Body of alpha_beta_search:
+ best_score = -np.inf
+ beta = np.inf
best_action = None
for a in game.actions(state):
v = min_value(game.result(state, a), best_score, beta)
@@ -82,20 +127,19 @@ def min_value(state, alpha, beta):
return best_action
-def alphabeta_cutoff_search(state, game, d=4, cutoff_test=None, eval_fn=None):
+def alpha_beta_cutoff_search(state, game, d=4, cutoff_test=None, eval_fn=None):
"""Search game to determine best action; use alpha-beta pruning.
This version cuts off search and uses an evaluation function."""
player = game.to_move(state)
- # Functions used by alphabeta
+ # Functions used by alpha_beta
def max_value(state, alpha, beta, depth):
if cutoff_test(state, depth):
return eval_fn(state)
- v = -infinity
+ v = -np.inf
for a in game.actions(state):
- v = max(v, min_value(game.result(state, a),
- alpha, beta, depth + 1))
+ v = max(v, min_value(game.result(state, a), alpha, beta, depth + 1))
if v >= beta:
return v
alpha = max(alpha, v)
@@ -104,23 +148,20 @@ def max_value(state, alpha, beta, depth):
def min_value(state, alpha, beta, depth):
if cutoff_test(state, depth):
return eval_fn(state)
- v = infinity
+ v = np.inf
for a in game.actions(state):
- v = min(v, max_value(game.result(state, a),
- alpha, beta, depth + 1))
+ v = min(v, max_value(game.result(state, a), alpha, beta, depth + 1))
if v <= alpha:
return v
beta = min(beta, v)
return v
- # Body of alphabeta_cutoff_search starts here:
+ # Body of alpha_beta_cutoff_search starts here:
# The default test cuts off at depth d or at a terminal state
- cutoff_test = (cutoff_test or
- (lambda state, depth: depth > d or
- game.terminal_test(state)))
+ cutoff_test = (cutoff_test or (lambda state, depth: depth > d or game.terminal_test(state)))
eval_fn = eval_fn or (lambda state: game.utility(state, player))
- best_score = -infinity
- beta = infinity
+ best_score = -np.inf
+ beta = np.inf
best_action = None
for a in game.actions(state):
v = min_value(game.result(state, a), best_score, beta, 1)
@@ -129,6 +170,7 @@ def min_value(state, alpha, beta, depth):
best_action = a
return best_action
+
# ______________________________________________________________________________
# Players for Games
@@ -139,21 +181,33 @@ def query_player(game, state):
game.display(state)
print("available moves: {}".format(game.actions(state)))
print("")
- move_string = input('Your move? ')
- try:
- move = eval(move_string)
- except NameError:
- move = move_string
+ move = None
+ if game.actions(state):
+ move_string = input('Your move? ')
+ try:
+ move = eval(move_string)
+ except NameError:
+ move = move_string
+ else:
+ print('no legal moves: passing turn to next player')
return move
def random_player(game, state):
"""A player that chooses a legal move at random."""
- return random.choice(game.actions(state))
+ return random.choice(game.actions(state)) if game.actions(state) else None
+
+
+def alpha_beta_player(game, state):
+ return alpha_beta_search(state, game)
+
+def minmax_player(game,state):
+ return minmax_decision(state,game)
-def alphabeta_player(game, state):
- return alphabeta_search(state, game)
+
+def expect_minmax_player(game, state):
+ return expect_minmax(state, game)
# ______________________________________________________________________________
@@ -208,6 +262,38 @@ def play_game(self, *players):
return self.utility(state, self.to_move(self.initial))
+class StochasticGame(Game):
+ """A stochastic game includes uncertain events which influence
+ the moves of players at each state. To create a stochastic game, subclass
+ this class and implement chances and outcome along with the other
+ unimplemented game class methods."""
+
+ def chances(self, state):
+ """Return a list of all possible uncertain events at a state."""
+ raise NotImplementedError
+
+ def outcome(self, state, chance):
+ """Return the state which is the outcome of a chance trial."""
+ raise NotImplementedError
+
+ def probability(self, chance):
+ """Return the probability of occurrence of a chance."""
+ raise NotImplementedError
+
+ def play_game(self, *players):
+ """Play an n-person, move-alternating stochastic game."""
+ state = self.initial
+ while True:
+ for player in players:
+ chance = random.choice(self.chances(state))
+ state = self.outcome(state, chance)
+ move = player(self, state)
+ state = self.result(state, move)
+ if self.terminal_test(state):
+ self.display(state)
+ return self.utility(state, self.to_move(self.initial))
+
+
class Fig52Game(Game):
"""The game represented in [Figure 5.2]. Serves as a simple test case."""
@@ -240,7 +326,7 @@ def to_move(self, state):
class Fig52Extended(Game):
"""Similar to Fig52Game but bigger. Useful for visualisation"""
- succs = {i:dict(l=i*3+1, m=i*3+2, r=i*3+3) for i in range(13)}
+ succs = {i: dict(l=i * 3 + 1, m=i * 3 + 2, r=i * 3 + 3) for i in range(13)}
utils = dict()
def actions(self, state):
@@ -261,6 +347,7 @@ def terminal_test(self, state):
def to_move(self, state):
return 'MIN' if state in {1, 2, 3} else 'MAX'
+
class TicTacToe(Game):
"""Play TicTacToe on an h x v board, with Max (first player) playing 'X'.
A state has the player to move, a cached utility, a list of moves in
@@ -341,4 +428,163 @@ def __init__(self, h=7, v=6, k=4):
def actions(self, state):
return [(x, y) for (x, y) in state.moves
- if y == 1 or (x, y - 1) in state.board]
+ if x == self.h or (x + 1 , y ) in state.board]
+
+class Gomoku(TicTacToe):
+ """Also known as Five in a row."""
+
+ def __init__(self, h=15, v=16, k=5):
+ TicTacToe.__init__(self, h, v, k)
+
+
+class Backgammon(StochasticGame):
+ """A two player game where the goal of each player is to move all the
+ checkers off the board. The moves for each state are determined by
+ rolling a pair of dice."""
+
+ def __init__(self):
+ """Initial state of the game"""
+ point = {'W': 0, 'B': 0}
+ board = [point.copy() for index in range(24)]
+ board[0]['B'] = board[23]['W'] = 2
+ board[5]['W'] = board[18]['B'] = 5
+ board[7]['W'] = board[16]['B'] = 3
+ board[11]['B'] = board[12]['W'] = 5
+ self.allow_bear_off = {'W': False, 'B': False}
+ self.direction = {'W': -1, 'B': 1}
+ self.initial = StochasticGameState(to_move='W',
+ utility=0,
+ board=board,
+ moves=self.get_all_moves(board, 'W'), chance=None)
+
+ def actions(self, state):
+ """Return a list of legal moves for a state."""
+ player = state.to_move
+ moves = state.moves
+ if len(moves) == 1 and len(moves[0]) == 1:
+ return moves
+ legal_moves = []
+ for move in moves:
+ board = copy.deepcopy(state.board)
+ if self.is_legal_move(board, move, state.chance, player):
+ legal_moves.append(move)
+ return legal_moves
+
+ def result(self, state, move):
+ board = copy.deepcopy(state.board)
+ player = state.to_move
+ self.move_checker(board, move[0], state.chance[0], player)
+ if len(move) == 2:
+ self.move_checker(board, move[1], state.chance[1], player)
+ to_move = ('W' if player == 'B' else 'B')
+ return StochasticGameState(to_move=to_move,
+ utility=self.compute_utility(board, move, player),
+ board=board,
+ moves=self.get_all_moves(board, to_move), chance=None)
+
+ def utility(self, state, player):
+ """Return the value to player; 1 for win, -1 for loss, 0 otherwise."""
+ return state.utility if player == 'W' else -state.utility
+
+ def terminal_test(self, state):
+ """A state is terminal if one player wins."""
+ return state.utility != 0
+
+ def get_all_moves(self, board, player):
+ """All possible moves for a player i.e. all possible ways of
+ choosing two checkers of a player from the board for a move
+ at a given state."""
+ all_points = board
+ taken_points = [index for index, point in enumerate(all_points)
+ if point[player] > 0]
+ if self.checkers_at_home(board, player) == 1:
+ return [(taken_points[0],)]
+ moves = list(itertools.permutations(taken_points, 2))
+ moves = moves + [(index, index) for index, point in enumerate(all_points)
+ if point[player] >= 2]
+ return moves
+
+ def display(self, state):
+ """Display state of the game."""
+ board = state.board
+ player = state.to_move
+ print("current state : ")
+ for index, point in enumerate(board):
+ print("point : ", index, " W : ", point['W'], " B : ", point['B'])
+ print("to play : ", player)
+
+ def compute_utility(self, board, move, player):
+ """If 'W' wins with this move, return 1; if 'B' wins return -1; else return 0."""
+ util = {'W': 1, 'B': -1}
+ for idx in range(0, 24):
+ if board[idx][player] > 0:
+ return 0
+ return util[player]
+
+ def checkers_at_home(self, board, player):
+ """Return the no. of checkers at home for a player."""
+ sum_range = range(0, 7) if player == 'W' else range(17, 24)
+ count = 0
+ for idx in sum_range:
+ count = count + board[idx][player]
+ return count
+
+ def is_legal_move(self, board, start, steps, player):
+ """Move is a tuple which contains starting points of checkers to be
+ moved during a player's turn. An on-board move is legal if both the destinations
+ are open. A bear-off move is the one where a checker is moved off-board.
+ It is legal only after a player has moved all his checkers to his home."""
+ dest1, dest2 = vector_add(start, steps)
+ dest_range = range(0, 24)
+ move1_legal = move2_legal = False
+ if dest1 in dest_range:
+ if self.is_point_open(player, board[dest1]):
+ self.move_checker(board, start[0], steps[0], player)
+ move1_legal = True
+ else:
+ if self.allow_bear_off[player]:
+ self.move_checker(board, start[0], steps[0], player)
+ move1_legal = True
+ if not move1_legal:
+ return False
+ if dest2 in dest_range:
+ if self.is_point_open(player, board[dest2]):
+ move2_legal = True
+ else:
+ if self.allow_bear_off[player]:
+ move2_legal = True
+ return move1_legal and move2_legal
+
+ def move_checker(self, board, start, steps, player):
+ """Move a checker from starting point by a given number of steps"""
+ dest = start + steps
+ dest_range = range(0, 24)
+ board[start][player] -= 1
+ if dest in dest_range:
+ board[dest][player] += 1
+ if self.checkers_at_home(board, player) == 15:
+ self.allow_bear_off[player] = True
+
+ def is_point_open(self, player, point):
+ """A point is open for a player if the no. of opponent's
+ checkers already present on it is 0 or 1. A player can
+ move a checker to a point only if it is open."""
+ opponent = 'B' if player == 'W' else 'W'
+ return point[opponent] <= 1
+
+ def chances(self, state):
+ """Return a list of all possible dice rolls at a state."""
+ dice_rolls = list(itertools.combinations_with_replacement([1, 2, 3, 4, 5, 6], 2))
+ return dice_rolls
+
+ def outcome(self, state, chance):
+ """Return the state which is the outcome of a dice roll."""
+ dice = tuple(map((self.direction[state.to_move]).__mul__, chance))
+ return StochasticGameState(to_move=state.to_move,
+ utility=state.utility,
+ board=state.board,
+ moves=state.moves, chance=dice)
+
+ def probability(self, chance):
+ """Return the probability of occurrence of a dice roll."""
+ return 1 / 36 if chance[0] == chance[1] else 1 / 18
diff --git a/games4e.ipynb b/games4e.ipynb
new file mode 100644
index 000000000..5b619f7ed
--- /dev/null
+++ b/games4e.ipynb
@@ -0,0 +1,1667 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Game Tree Search\n",
+ "\n",
+ "We start with defining the abstract class `Game`, for turn-taking *n*-player games. We rely on, but do not define yet, the concept of a `state` of the game; we'll see later how individual games define states. For now, all we require is that a state has a `state.to_move` attribute, which gives the name of the player whose turn it is. (\"Name\" will be something like `'X'` or `'O'` for tic-tac-toe.) \n",
+ "\n",
+ "We also define `play_game`, which takes a game and a dictionary of `{player_name: strategy_function}` pairs, and plays out the game, on each turn checking `state.to_move` to see whose turn it is, and then getting the strategy function for that player and applying it to the game and the state to get a move."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from collections import namedtuple, Counter, defaultdict\n",
+ "import random\n",
+ "import math\n",
+ "import functools \n",
+ "cache = functools.lru_cache(10**6)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Game:\n",
+ " \"\"\"A game is similar to a problem, but it has a terminal test instead of \n",
+ " a goal test, and a utility for each terminal state. To create a game, \n",
+ " subclass this class and implement `actions`, `result`, `is_terminal`, \n",
+ " and `utility`. You will also need to set the .initial attribute to the \n",
+ " initial state; this can be done in the constructor.\"\"\"\n",
+ "\n",
+ " def actions(self, state):\n",
+ " \"\"\"Return a collection of the allowable moves from this state.\"\"\"\n",
+ " raise NotImplementedError\n",
+ "\n",
+ " def result(self, state, move):\n",
+ " \"\"\"Return the state that results from making a move from a state.\"\"\"\n",
+ " raise NotImplementedError\n",
+ "\n",
+ " def is_terminal(self, state):\n",
+ " \"\"\"Return True if this is a final state for the game.\"\"\"\n",
+ " return not self.actions(state)\n",
+ " \n",
+ " def utility(self, state, player):\n",
+ " \"\"\"Return the value of this final state to player.\"\"\"\n",
+ " raise NotImplementedError\n",
+ " \n",
+ "\n",
+ "def play_game(game, strategies: dict, verbose=False):\n",
+ " \"\"\"Play a turn-taking game. `strategies` is a {player_name: function} dict,\n",
+ " where function(state, game) is used to get the player's move.\"\"\"\n",
+ " state = game.initial\n",
+ " while not game.is_terminal(state):\n",
+ " player = state.to_move\n",
+ " move = strategies[player](game, state)\n",
+ " state = game.result(state, move)\n",
+ " if verbose: \n",
+ " print('Player', player, 'move:', move)\n",
+ " print(state)\n",
+ " return state"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Minimax-Based Game Search Algorithms\n",
+ "\n",
+ "We will define several game search algorithms. Each takes two inputs, the game we are playing and the current state of the game, and returns a a `(value, move)` pair, where `value` is the utility that the algorithm computes for the player whose turn it is to move, and `move` is the move itself.\n",
+ "\n",
+ "First we define `minimax_search`, which exhaustively searches the game tree to find an optimal move (assuming both players play optimally), and `alphabeta_search`, which does the same computation, but prunes parts of the tree that could not possibly have an affect on the optimnal move. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def minimax_search(game, state):\n",
+ " \"\"\"Search game tree to determine best move; return (value, move) pair.\"\"\"\n",
+ "\n",
+ " player = state.to_move\n",
+ "\n",
+ " def max_value(state):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = -infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = min_value(game.result(state, a))\n",
+ " if v2 > v:\n",
+ " v, move = v2, a\n",
+ " return v, move\n",
+ "\n",
+ " def min_value(state):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = +infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = max_value(game.result(state, a))\n",
+ " if v2 < v:\n",
+ " v, move = v2, a\n",
+ " return v, move\n",
+ "\n",
+ " return max_value(state)\n",
+ "\n",
+ "infinity = math.inf\n",
+ "\n",
+ "def alphabeta_search(game, state):\n",
+ " \"\"\"Search game to determine best action; use alpha-beta pruning.\n",
+ " As in [Figure 5.7], this version searches all the way to the leaves.\"\"\"\n",
+ "\n",
+ " player = state.to_move\n",
+ "\n",
+ " def max_value(state, alpha, beta):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = -infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = min_value(game.result(state, a), alpha, beta)\n",
+ " if v2 > v:\n",
+ " v, move = v2, a\n",
+ " alpha = max(alpha, v)\n",
+ " if v >= beta:\n",
+ " return v, move\n",
+ " return v, move\n",
+ "\n",
+ " def min_value(state, alpha, beta):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = +infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = max_value(game.result(state, a), alpha, beta)\n",
+ " if v2 < v:\n",
+ " v, move = v2, a\n",
+ " beta = min(beta, v)\n",
+ " if v <= alpha:\n",
+ " return v, move\n",
+ " return v, move\n",
+ "\n",
+ " return max_value(state, -infinity, +infinity)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# A Simple Game: Tic-Tac-Toe\n",
+ "\n",
+ "We have the notion of an abstract game, we have some search functions; now it is time to define a real game; a simple one, tic-tac-toe. Moves are `(x, y)` pairs denoting squares, where `(0, 0)` is the top left, and `(2, 2)` is the bottom right (on a board of size `height=width=3`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class TicTacToe(Game):\n",
+ " \"\"\"Play TicTacToe on an `height` by `width` board, needing `k` in a row to win.\n",
+ " 'X' plays first against 'O'.\"\"\"\n",
+ "\n",
+ " def __init__(self, height=3, width=3, k=3):\n",
+ " self.k = k # k in a row\n",
+ " self.squares = {(x, y) for x in range(width) for y in range(height)}\n",
+ " self.initial = Board(height=height, width=width, to_move='X', utility=0)\n",
+ "\n",
+ " def actions(self, board):\n",
+ " \"\"\"Legal moves are any square not yet taken.\"\"\"\n",
+ " return self.squares - set(board)\n",
+ "\n",
+ " def result(self, board, square):\n",
+ " \"\"\"Place a marker for current player on square.\"\"\"\n",
+ " player = board.to_move\n",
+ " board = board.new({square: player}, to_move=('O' if player == 'X' else 'X'))\n",
+ " win = k_in_row(board, player, square, self.k)\n",
+ " board.utility = (0 if not win else +1 if player == 'X' else -1)\n",
+ " return board\n",
+ "\n",
+ " def utility(self, board, player):\n",
+ " \"\"\"Return the value to player; 1 for win, -1 for loss, 0 otherwise.\"\"\"\n",
+ " return board.utility if player == 'X' else -board.utility\n",
+ "\n",
+ " def is_terminal(self, board):\n",
+ " \"\"\"A board is a terminal state if it is won or there are no empty squares.\"\"\"\n",
+ " return board.utility != 0 or len(self.squares) == len(board)\n",
+ "\n",
+ " def display(self, board): print(board) \n",
+ "\n",
+ "\n",
+ "def k_in_row(board, player, square, k):\n",
+ " \"\"\"True if player has k pieces in a line through square.\"\"\"\n",
+ " def in_row(x, y, dx, dy): return 0 if board[x, y] != player else 1 + in_row(x + dx, y + dy, dx, dy)\n",
+ " return any(in_row(*square, dx, dy) + in_row(*square, -dx, -dy) - 1 >= k\n",
+ " for (dx, dy) in ((0, 1), (1, 0), (1, 1), (1, -1)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "States in tic-tac-toe (and other games) will be represented as a `Board`, which is a subclass of `defaultdict` that in general will consist of `{(x, y): contents}` pairs, for example `{(0, 0): 'X', (1, 1): 'O'}` might be the state of the board after two moves. Besides the contents of squares, a board also has some attributes: \n",
+ "- `.to_move` to name the player whose move it is; \n",
+ "- `.width` and `.height` to give the size of the board (both 3 in tic-tac-toe, but other numbers in related games);\n",
+ "- possibly other attributes, as specified by keywords. \n",
+ "\n",
+ "As a `defaultdict`, the `Board` class has a `__missing__` method, which returns `empty` for squares that have no been assigned but are within the `width` × `height` boundaries, or `off` otherwise. The class has a `__hash__` method, so instances can be stored in hash tables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Board(defaultdict):\n",
+ " \"\"\"A board has the player to move, a cached utility value, \n",
+ " and a dict of {(x, y): player} entries, where player is 'X' or 'O'.\"\"\"\n",
+ " empty = '.'\n",
+ " off = '#'\n",
+ " \n",
+ " def __init__(self, width=8, height=8, to_move=None, **kwds):\n",
+ " self.__dict__.update(width=width, height=height, to_move=to_move, **kwds)\n",
+ " \n",
+ " def new(self, changes: dict, **kwds) -> 'Board':\n",
+ " \"Given a dict of {(x, y): contents} changes, return a new Board with the changes.\"\n",
+ " board = Board(width=self.width, height=self.height, **kwds)\n",
+ " board.update(self)\n",
+ " board.update(changes)\n",
+ " return board\n",
+ "\n",
+ " def __missing__(self, loc):\n",
+ " x, y = loc\n",
+ " if 0 <= x < self.width and 0 <= y < self.height:\n",
+ " return self.empty\n",
+ " else:\n",
+ " return self.off\n",
+ " \n",
+ " def __hash__(self): \n",
+ " return hash(tuple(sorted(self.items()))) + hash(self.to_move)\n",
+ " \n",
+ " def __repr__(self):\n",
+ " def row(y): return ' '.join(self[x, y] for x in range(self.width))\n",
+ " return '\\n'.join(map(row, range(self.height))) + '\\n'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Players\n",
+ "\n",
+ "We need an interface for players. I'll represent a player as a `callable` that will be passed two arguments: `(game, state)` and will return a `move`.\n",
+ "The function `player` creates a player out of a search algorithm, but you can create your own players as functions, as is done with `random_player` below:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def random_player(game, state): return random.choice(list(game.actions(state)))\n",
+ "\n",
+ "def player(search_algorithm):\n",
+ " \"\"\"A game player who uses the specified search algorithm\"\"\"\n",
+ " return lambda game, state: search_algorithm(game, state)[1]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Playing a Game\n",
+ "\n",
+ "We're ready to play a game. I'll set up a match between a `random_player` (who chooses randomly from the legal moves) and a `player(alphabeta_search)` (who makes the optimal alpha-beta move; practical for tic-tac-toe, but not for large games). The `player(alphabeta_search)` will never lose, but if `random_player` is lucky, it will be a tie."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Player X move: (0, 0)\n",
+ "X . .\n",
+ ". . .\n",
+ ". . .\n",
+ "\n",
+ "Player O move: (1, 1)\n",
+ "X . .\n",
+ ". O .\n",
+ ". . .\n",
+ "\n",
+ "Player X move: (1, 2)\n",
+ "X . .\n",
+ ". O .\n",
+ ". X .\n",
+ "\n",
+ "Player O move: (0, 1)\n",
+ "X . .\n",
+ "O O .\n",
+ ". X .\n",
+ "\n",
+ "Player X move: (2, 1)\n",
+ "X . .\n",
+ "O O X\n",
+ ". X .\n",
+ "\n",
+ "Player O move: (2, 0)\n",
+ "X . O\n",
+ "O O X\n",
+ ". X .\n",
+ "\n",
+ "Player X move: (2, 2)\n",
+ "X . O\n",
+ "O O X\n",
+ ". X X\n",
+ "\n",
+ "Player O move: (0, 2)\n",
+ "X . O\n",
+ "O O X\n",
+ "O X X\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 74,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "play_game(TicTacToe(), dict(X=random_player, O=player(alphabeta_search)), verbose=True).utility"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The alpha-beta player will never lose, but sometimes the random player can stumble into a draw. When two optimal (alpha-beta or minimax) players compete, it will always be a draw:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Player X move: (0, 1)\n",
+ ". . .\n",
+ "X . .\n",
+ ". . .\n",
+ "\n",
+ "Player O move: (0, 0)\n",
+ "O . .\n",
+ "X . .\n",
+ ". . .\n",
+ "\n",
+ "Player X move: (2, 0)\n",
+ "O . X\n",
+ "X . .\n",
+ ". . .\n",
+ "\n",
+ "Player O move: (2, 1)\n",
+ "O . X\n",
+ "X . O\n",
+ ". . .\n",
+ "\n",
+ "Player X move: (1, 2)\n",
+ "O . X\n",
+ "X . O\n",
+ ". X .\n",
+ "\n",
+ "Player O move: (0, 2)\n",
+ "O . X\n",
+ "X . O\n",
+ "O X .\n",
+ "\n",
+ "Player X move: (1, 0)\n",
+ "O X X\n",
+ "X . O\n",
+ "O X .\n",
+ "\n",
+ "Player O move: (1, 1)\n",
+ "O X X\n",
+ "X O O\n",
+ "O X .\n",
+ "\n",
+ "Player X move: (2, 2)\n",
+ "O X X\n",
+ "X O O\n",
+ "O X X\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 75,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "play_game(TicTacToe(), dict(X=player(alphabeta_search), O=player(minimax_search)), verbose=True).utility"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Connect Four\n",
+ "\n",
+ "Connect Four is a variant of tic-tac-toe, played on a larger (7 x 6) board, and with the restriction that in any column you can only play in the lowest empty square in the column."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 76,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class ConnectFour(TicTacToe):\n",
+ " \n",
+ " def __init__(self): super().__init__(width=7, height=6, k=4)\n",
+ "\n",
+ " def actions(self, board):\n",
+ " \"\"\"In each column you can play only the lowest empty square in the column.\"\"\"\n",
+ " return {(x, y) for (x, y) in self.squares - set(board)\n",
+ " if y == board.height - 1 or (x, y + 1) in board}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Player X move: (2, 5)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . . .\n",
+ "\n",
+ "Player O move: (1, 5)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O X . . . .\n",
+ "\n",
+ "Player X move: (5, 5)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O X . . X .\n",
+ "\n",
+ "Player O move: (4, 5)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O X . O X .\n",
+ "\n",
+ "Player X move: (4, 4)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . X . .\n",
+ ". O X . O X .\n",
+ "\n",
+ "Player O move: (2, 4)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . O . X . .\n",
+ ". O X . O X .\n",
+ "\n",
+ "Player X move: (2, 3)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . . .\n",
+ ". . O . X . .\n",
+ ". O X . O X .\n",
+ "\n",
+ "Player O move: (1, 4)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . . .\n",
+ ". O O . X . .\n",
+ ". O X . O X .\n",
+ "\n",
+ "Player X move: (0, 5)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . . .\n",
+ ". O O . X . .\n",
+ "X O X . O X .\n",
+ "\n",
+ "Player O move: (5, 4)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . . .\n",
+ ". O O . X O .\n",
+ "X O X . O X .\n",
+ "\n",
+ "Player X move: (5, 3)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . X .\n",
+ ". O O . X O .\n",
+ "X O X . O X .\n",
+ "\n",
+ "Player O move: (6, 5)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . X . . X .\n",
+ ". O O . X O .\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (1, 3)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". X X . . X .\n",
+ ". O O . X O .\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player O move: (6, 4)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". X X . . X .\n",
+ ". O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (5, 2)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X .\n",
+ ". X X . . X .\n",
+ ". O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player O move: (0, 4)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X .\n",
+ ". X X . . X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (0, 3)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X .\n",
+ "X X X . . X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player O move: (0, 2)\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ "O . . . . X .\n",
+ "X X X . . X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (0, 1)\n",
+ ". . . . . . .\n",
+ "X . . . . . .\n",
+ "O . . . . X .\n",
+ "X X X . . X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player O move: (0, 0)\n",
+ "O . . . . . .\n",
+ "X . . . . . .\n",
+ "O . . . . X .\n",
+ "X X X . . X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (5, 1)\n",
+ "O . . . . . .\n",
+ "X . . . . X .\n",
+ "O . . . . X .\n",
+ "X X X . . X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player O move: (4, 3)\n",
+ "O . . . . . .\n",
+ "X . . . . X .\n",
+ "O . . . . X .\n",
+ "X X X . O X .\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (6, 3)\n",
+ "O . . . . . .\n",
+ "X . . . . X .\n",
+ "O . . . . X .\n",
+ "X X X . O X X\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player O move: (5, 0)\n",
+ "O . . . . O .\n",
+ "X . . . . X .\n",
+ "O . . . . X .\n",
+ "X X X . O X X\n",
+ "O O O . X O O\n",
+ "X O X . O X O\n",
+ "\n",
+ "Player X move: (3, 5)\n",
+ "O . . . . O .\n",
+ "X . . . . X .\n",
+ "O . . . . X .\n",
+ "X X X . O X X\n",
+ "O O O . X O O\n",
+ "X O X X O X O\n",
+ "\n",
+ "Player O move: (1, 2)\n",
+ "O . . . . O .\n",
+ "X . . . . X .\n",
+ "O O . . . X .\n",
+ "X X X . O X X\n",
+ "O O O . X O O\n",
+ "X O X X O X O\n",
+ "\n",
+ "Player X move: (1, 1)\n",
+ "O . . . . O .\n",
+ "X X . . . X .\n",
+ "O O . . . X .\n",
+ "X X X . O X X\n",
+ "O O O . X O O\n",
+ "X O X X O X O\n",
+ "\n",
+ "Player O move: (3, 4)\n",
+ "O . . . . O .\n",
+ "X X . . . X .\n",
+ "O O . . . X .\n",
+ "X X X . O X X\n",
+ "O O O O X O O\n",
+ "X O X X O X O\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "-1"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "play_game(ConnectFour(), dict(X=random_player, O=random_player), verbose=True).utility"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Transposition Tables\n",
+ "\n",
+ "By treating the game tree as a tree, we can arrive at the same state through different paths, and end up duplicating effort. In state-space search, we kept a table of `reached` states to prevent this. For game-tree search, we can achieve the same effect by applying the `@cache` decorator to the `min_value` and `max_value` functions. We'll use the suffix `_tt` to indicate a function that uses these transisiton tables."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def minimax_search_tt(game, state):\n",
+ " \"\"\"Search game to determine best move; return (value, move) pair.\"\"\"\n",
+ "\n",
+ " player = state.to_move\n",
+ "\n",
+ " @cache\n",
+ " def max_value(state):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = -infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = min_value(game.result(state, a))\n",
+ " if v2 > v:\n",
+ " v, move = v2, a\n",
+ " return v, move\n",
+ "\n",
+ " @cache\n",
+ " def min_value(state):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = +infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = max_value(game.result(state, a))\n",
+ " if v2 < v:\n",
+ " v, move = v2, a\n",
+ " return v, move\n",
+ "\n",
+ " return max_value(state)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For alpha-beta search, we can still use a cache, but it should be based just on the state, not on whatever values alpha and beta have."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def cache1(function):\n",
+ " \"Like lru_cache(None), but only considers the first argument of function.\"\n",
+ " cache = {}\n",
+ " def wrapped(x, *args):\n",
+ " if x not in cache:\n",
+ " cache[x] = function(x, *args)\n",
+ " return cache[x]\n",
+ " return wrapped\n",
+ "\n",
+ "def alphabeta_search_tt(game, state):\n",
+ " \"\"\"Search game to determine best action; use alpha-beta pruning.\n",
+ " As in [Figure 5.7], this version searches all the way to the leaves.\"\"\"\n",
+ "\n",
+ " player = state.to_move\n",
+ "\n",
+ " @cache1\n",
+ " def max_value(state, alpha, beta):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = -infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = min_value(game.result(state, a), alpha, beta)\n",
+ " if v2 > v:\n",
+ " v, move = v2, a\n",
+ " alpha = max(alpha, v)\n",
+ " if v >= beta:\n",
+ " return v, move\n",
+ " return v, move\n",
+ "\n",
+ " @cache1\n",
+ " def min_value(state, alpha, beta):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " v, move = +infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = max_value(game.result(state, a), alpha, beta)\n",
+ " if v2 < v:\n",
+ " v, move = v2, a\n",
+ " beta = min(beta, v)\n",
+ " if v <= alpha:\n",
+ " return v, move\n",
+ " return v, move\n",
+ "\n",
+ " return max_value(state, -infinity, +infinity)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: user 593 ms, sys: 52 ms, total: 645 ms\n",
+ "Wall time: 655 ms\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "O X X\n",
+ "X O O\n",
+ "O X X"
+ ]
+ },
+ "execution_count": 81,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "%time play_game(TicTacToe(), {'X':player(alphabeta_search_tt), 'O':player(minimax_search_tt)})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: user 3.07 s, sys: 30.7 ms, total: 3.1 s\n",
+ "Wall time: 3.15 s\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "O X X\n",
+ "X O O\n",
+ "O X X"
+ ]
+ },
+ "execution_count": 82,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "%time play_game(TicTacToe(), {'X':player(alphabeta_search), 'O':player(minimax_search)})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Heuristic Cutoffs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def cutoff_depth(d):\n",
+ " \"\"\"A cutoff function that searches to depth d.\"\"\"\n",
+ " return lambda game, state, depth: depth > d\n",
+ "\n",
+ "def h_alphabeta_search(game, state, cutoff=cutoff_depth(6), h=lambda s, p: 0):\n",
+ " \"\"\"Search game to determine best action; use alpha-beta pruning.\n",
+ " As in [Figure 5.7], this version searches all the way to the leaves.\"\"\"\n",
+ "\n",
+ " player = state.to_move\n",
+ "\n",
+ " @cache1\n",
+ " def max_value(state, alpha, beta, depth):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " if cutoff(game, state, depth):\n",
+ " return h(state, player), None\n",
+ " v, move = -infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = min_value(game.result(state, a), alpha, beta, depth+1)\n",
+ " if v2 > v:\n",
+ " v, move = v2, a\n",
+ " alpha = max(alpha, v)\n",
+ " if v >= beta:\n",
+ " return v, move\n",
+ " return v, move\n",
+ "\n",
+ " @cache1\n",
+ " def min_value(state, alpha, beta, depth):\n",
+ " if game.is_terminal(state):\n",
+ " return game.utility(state, player), None\n",
+ " if cutoff(game, state, depth):\n",
+ " return h(state, player), None\n",
+ " v, move = +infinity, None\n",
+ " for a in game.actions(state):\n",
+ " v2, _ = max_value(game.result(state, a), alpha, beta, depth + 1)\n",
+ " if v2 < v:\n",
+ " v, move = v2, a\n",
+ " beta = min(beta, v)\n",
+ " if v <= alpha:\n",
+ " return v, move\n",
+ " return v, move\n",
+ "\n",
+ " return max_value(state, -infinity, +infinity, 0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CPU times: user 367 ms, sys: 7.9 ms, total: 375 ms\n",
+ "Wall time: 375 ms\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "O X X\n",
+ "X O O\n",
+ "O X X"
+ ]
+ },
+ "execution_count": 54,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "%time play_game(TicTacToe(), {'X':player(h_alphabeta_search), 'O':player(h_alphabeta_search)})"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . X\n",
+ ". . . . . X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O X\n",
+ ". . . . . X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O X\n",
+ ". . . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . . O X\n",
+ ". . . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . X O X\n",
+ ". . . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . X O X\n",
+ ". O . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". X . . X O X\n",
+ ". O . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O O\n",
+ ". X . . X O X\n",
+ ". O . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . X O O\n",
+ ". X . . X O X\n",
+ ". O . . X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . X O O\n",
+ ". X . . X O X\n",
+ ". O . O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X .\n",
+ ". . . . X O O\n",
+ ". X . . X O X\n",
+ ". O . O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . . X .\n",
+ ". . . . X O O\n",
+ ". X . . X O X\n",
+ ". O . O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . . X .\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ ". O . O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . . X O\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ ". O . O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ ". O . O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ ". O O O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . O O\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . . X\n",
+ ". . . . . O O\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ ". X . . X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . . X\n",
+ ". . . . . O O\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ "O X . . X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . . . O O\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ "O X . . X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . . . O O\n",
+ ". X . . . X O\n",
+ ". X . . X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . . . O O\n",
+ ". X . . . X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . . . O O\n",
+ ". X . . O X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . . . O O\n",
+ ". X . X O X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . . O O O\n",
+ ". X . X O X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . . X X\n",
+ ". . . X O O O\n",
+ ". X . X O X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . . O X X\n",
+ ". . . X O O O\n",
+ ". X . X O X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ ". . . X O X X\n",
+ ". . . X O O O\n",
+ ". X . X O X O\n",
+ ". X . X X O O\n",
+ "O X . O X O X\n",
+ "X O O O X X O\n",
+ "\n",
+ "CPU times: user 8.82 s, sys: 146 ms, total: 8.96 s\n",
+ "Wall time: 9.19 s\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 60,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "%time play_game(ConnectFour(), {'X':player(h_alphabeta_search), 'O':random_player}, verbose=True).utility"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . . X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . . . X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . O .\n",
+ ". . O . X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . X O .\n",
+ ". . O . X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . X O .\n",
+ ". . O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . X O .\n",
+ ". X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O . . X O .\n",
+ ". X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". X . . . . .\n",
+ ". O . . X O .\n",
+ ". X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O . . . . .\n",
+ ". X . . . . .\n",
+ ". O . . X O .\n",
+ ". X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O . . . . .\n",
+ ". X . . . . .\n",
+ ". O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O . . . . .\n",
+ ". X . . . . .\n",
+ "O O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O . . . . .\n",
+ ". X . . X . .\n",
+ "O O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . . . .\n",
+ ". O . . O . .\n",
+ ". X . . X . .\n",
+ "O O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X . .\n",
+ ". O . . O . .\n",
+ ". X . . X . .\n",
+ "O O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X . .\n",
+ ". O . . O . .\n",
+ ". X . . X O .\n",
+ "O O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X . .\n",
+ ". O . . O X .\n",
+ ". X . . X O .\n",
+ "O O . . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X . .\n",
+ ". O . . O X .\n",
+ ". X . . X O .\n",
+ "O O O . X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X . .\n",
+ ". O . . O X .\n",
+ ". X . . X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X O .\n",
+ ". O . . O X .\n",
+ ". X . . X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X O .\n",
+ ". O . . O X .\n",
+ ". X . X X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . . X O .\n",
+ ". O . O O X .\n",
+ ". X . X X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . . . . .\n",
+ ". . . X X O .\n",
+ ". O . O O X .\n",
+ ". X . X X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . O . . .\n",
+ ". . . X X O .\n",
+ ". O . O O X .\n",
+ ". X . X X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ ". . . O . . .\n",
+ ". . . X X O .\n",
+ ". O . O O X .\n",
+ ". X X X X O .\n",
+ "O O O X X O .\n",
+ "X X O O X X .\n",
+ "\n",
+ "CPU times: user 12.1 s, sys: 237 ms, total: 12.4 s\n",
+ "Wall time: 12.9 s\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "execution_count": 61,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "%time play_game(ConnectFour(), {'X':player(h_alphabeta_search), 'O':player(h_alphabeta_search)}, verbose=True).utility"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Result states: 6,589; Terminal tests: 3,653; for alphabeta_search_tt\n",
+ "Result states: 25,703; Terminal tests: 25,704; for alphabeta_search\n",
+ "Result states: 4,687; Terminal tests: 2,805; for h_alphabeta_search\n",
+ "Result states: 16,167; Terminal tests: 5,478; for minimax_search_tt\n"
+ ]
+ }
+ ],
+ "source": [
+ "class CountCalls:\n",
+ " \"\"\"Delegate all attribute gets to the object, and count them in ._counts\"\"\"\n",
+ " def __init__(self, obj):\n",
+ " self._object = obj\n",
+ " self._counts = Counter()\n",
+ " \n",
+ " def __getattr__(self, attr):\n",
+ " \"Delegate to the original object, after incrementing a counter.\"\n",
+ " self._counts[attr] += 1\n",
+ " return getattr(self._object, attr)\n",
+ " \n",
+ "def report(game, searchers):\n",
+ " for searcher in searchers:\n",
+ " game = CountCalls(game)\n",
+ " searcher(game, game.initial)\n",
+ " print('Result states: {:7,d}; Terminal tests: {:7,d}; for {}'.format(\n",
+ " game._counts['result'], game._counts['is_terminal'], searcher.__name__))\n",
+ " \n",
+ "report(TicTacToe(), (alphabeta_search_tt, alphabeta_search, h_alphabeta_search, minimax_search_tt))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Monte Carlo Tree Search"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Node:\n",
+ " def __init__(self, parent, )\n",
+ "def mcts(state, game, N=1000):"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Heuristic Search Algorithms"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "t = CountCalls(TicTacToe())\n",
+ " \n",
+ "play_game(t, dict(X=minimax_player, O=minimax_player), verbose=True)\n",
+ "t._counts"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for tactic in (three, fork, center, opposite_corner, corner, any):\n",
+ " for s in squares:\n",
+ " if tactic(board, s,player): return s\n",
+ " for s ins quares:\n",
+ " if tactic(board, s, opponent): return s"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "\n",
+ "def ucb(U, N, C=2**0.5, parentN=100):\n",
+ " return round(U/N + C * math.sqrt(math.log(parentN)/N), 2)\n",
+ "\n",
+ "{C: (ucb(60, 79, C), ucb(1, 10, C), ucb(2, 11, C)) \n",
+ " for C in (1.4, 1.5)}\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def ucb(U, N, parentN=100, C=2):\n",
+ " return U/N + C * math.sqrt(math.log(parentN)/N)\n",
+ "\n",
+ "\n",
+ "C = 1.4 \n",
+ "\n",
+ "class Node:\n",
+ " def __init__(self, name, children=(), U=0, N=0, parent=None, p=0.5):\n",
+ " self.__dict__.update(name=name, U=U, N=N, parent=parent, children=children, p=p)\n",
+ " for c in children:\n",
+ " c.parent = self\n",
+ " \n",
+ " def __repr__(self):\n",
+ " return '{}:{}/{}={:.0%}{}'.format(self.name, self.U, self.N, self.U/self.N, self.children)\n",
+ " \n",
+ "def select(n):\n",
+ " if n.children:\n",
+ " return select(max(n.children, key=ucb))\n",
+ " else:\n",
+ " return n\n",
+ " \n",
+ "def back(n, amount):\n",
+ " if n:\n",
+ " n.N += 1\n",
+ " n.U += amount\n",
+ " back(n.parent, 1 - amount)\n",
+ " \n",
+ " \n",
+ "def one(root): \n",
+ " n = select(root)\n",
+ " amount = int(random.uniform(0, 1) < n.p)\n",
+ " back(n, amount)\n",
+ " \n",
+ "def ucb(n): \n",
+ " return (float('inf') if n.N == 0 else\n",
+ " n.U / n.N + C * math.sqrt(math.log(n.parent.N)/n.N))\n",
+ "\n",
+ "\n",
+ "tree = Node('root', [Node('a', p=.8, children=[Node('a1', p=.05), \n",
+ " Node('a2', p=.25,\n",
+ " children=[Node('a2a', p=.7), Node('a2b')])]),\n",
+ " Node('b', p=.5, children=[Node('b1', p=.6,\n",
+ " children=[Node('b1a', p=.3), Node('b1b')]), \n",
+ " Node('b2', p=.4)]),\n",
+ " Node('c', p=.1)])\n",
+ "\n",
+ "for i in range(100):\n",
+ " one(tree); \n",
+ "for c in tree.children: print(c)\n",
+ "'select', select(tree), 'tree', tree\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "us = (100, 50, 25, 10, 5, 1)\n",
+ "infinity = float('inf')\n",
+ "\n",
+ "@lru_cache(None)\n",
+ "def f1(n, denom):\n",
+ " return (0 if n == 0 else\n",
+ " infinity if n < 0 or not denom else\n",
+ " min(1 + f1(n - denom[0], denom),\n",
+ " f1(n, denom[1:])))\n",
+ " \n",
+ "@lru_cache(None)\n",
+ "def f2(n, denom):\n",
+ " @lru_cache(None)\n",
+ " def f(n):\n",
+ " return (0 if n == 0 else\n",
+ " infinity if n < 0 else\n",
+ " 1 + min(f(n - d) for d in denom))\n",
+ " return f(n)\n",
+ "\n",
+ "@lru_cache(None)\n",
+ "def f3(n, denom):\n",
+ " return (0 if n == 0 else\n",
+ " infinity if n < 0 or not denom else\n",
+ " min(k + f2(n - k * denom[0], denom[1:]) \n",
+ " for k in range(1 + n // denom[0])))\n",
+ " \n",
+ "\n",
+ "def g(n, d=us): return f1(n, d), f2(n, d), f3(n, d)\n",
+ " \n",
+ "n = 12345\n",
+ "%time f1(n, us)\n",
+ "%time f2(n, us)\n",
+ "%time f3(n, us)\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.2"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/games4e.py b/games4e.py
new file mode 100644
index 000000000..aba5b0eb3
--- /dev/null
+++ b/games4e.py
@@ -0,0 +1,635 @@
+"""Games or Adversarial Search (Chapter 5)"""
+
+import copy
+import itertools
+import random
+from collections import namedtuple
+
+import numpy as np
+
+from utils4e import vector_add, MCT_Node, ucb
+
+GameState = namedtuple('GameState', 'to_move, utility, board, moves')
+StochasticGameState = namedtuple('StochasticGameState', 'to_move, utility, board, moves, chance')
+
+
+# ______________________________________________________________________________
+# MinMax Search
+
+
+def minmax_decision(state, game):
+ """Given a state in a game, calculate the best move by searching
+ forward all the way to the terminal states. [Figure 5.3]"""
+
+ player = game.to_move(state)
+
+ def max_value(state):
+ if game.terminal_test(state):
+ return game.utility(state, player)
+ v = -np.inf
+ for a in game.actions(state):
+ v = max(v, min_value(game.result(state, a)))
+ return v
+
+ def min_value(state):
+ if game.terminal_test(state):
+ return game.utility(state, player)
+ v = np.inf
+ for a in game.actions(state):
+ v = min(v, max_value(game.result(state, a)))
+ return v
+
+ # Body of minmax_decision:
+ return max(game.actions(state), key=lambda a: min_value(game.result(state, a)))
+
+
+# ______________________________________________________________________________
+
+
+def expect_minmax(state, game):
+ """
+ [Figure 5.11]
+ Return the best move for a player after dice are thrown. The game tree
+ includes chance nodes along with min and max nodes.
+ """
+ player = game.to_move(state)
+
+ def max_value(state):
+ v = -np.inf
+ for a in game.actions(state):
+ v = max(v, chance_node(state, a))
+ return v
+
+ def min_value(state):
+ v = np.inf
+ for a in game.actions(state):
+ v = min(v, chance_node(state, a))
+ return v
+
+ def chance_node(state, action):
+ res_state = game.result(state, action)
+ if game.terminal_test(res_state):
+ return game.utility(res_state, player)
+ sum_chances = 0
+ num_chances = len(game.chances(res_state))
+ for chance in game.chances(res_state):
+ res_state = game.outcome(res_state, chance)
+ util = 0
+ if res_state.to_move == player:
+ util = max_value(res_state)
+ else:
+ util = min_value(res_state)
+ sum_chances += util * game.probability(chance)
+ return sum_chances / num_chances
+
+ # Body of expect_min_max:
+ return max(game.actions(state), key=lambda a: chance_node(state, a), default=None)
+
+
+def alpha_beta_search(state, game):
+ """Search game to determine best action; use alpha-beta pruning.
+ As in [Figure 5.7], this version searches all the way to the leaves."""
+
+ player = game.to_move(state)
+
+ # Functions used by alpha_beta
+ def max_value(state, alpha, beta):
+ if game.terminal_test(state):
+ return game.utility(state, player)
+ v = -np.inf
+ for a in game.actions(state):
+ v = max(v, min_value(game.result(state, a), alpha, beta))
+ if v >= beta:
+ return v
+ alpha = max(alpha, v)
+ return v
+
+ def min_value(state, alpha, beta):
+ if game.terminal_test(state):
+ return game.utility(state, player)
+ v = np.inf
+ for a in game.actions(state):
+ v = min(v, max_value(game.result(state, a), alpha, beta))
+ if v <= alpha:
+ return v
+ beta = min(beta, v)
+ return v
+
+ # Body of alpha_beta_search:
+ best_score = -np.inf
+ beta = np.inf
+ best_action = None
+ for a in game.actions(state):
+ v = min_value(game.result(state, a), best_score, beta)
+ if v > best_score:
+ best_score = v
+ best_action = a
+ return best_action
+
+
+def alpha_beta_cutoff_search(state, game, d=4, cutoff_test=None, eval_fn=None):
+ """Search game to determine best action; use alpha-beta pruning.
+ This version cuts off search and uses an evaluation function."""
+
+ player = game.to_move(state)
+
+ # Functions used by alpha_beta
+ def max_value(state, alpha, beta, depth):
+ if cutoff_test(state, depth):
+ return eval_fn(state)
+ v = -np.inf
+ for a in game.actions(state):
+ v = max(v, min_value(game.result(state, a), alpha, beta, depth + 1))
+ if v >= beta:
+ return v
+ alpha = max(alpha, v)
+ return v
+
+ def min_value(state, alpha, beta, depth):
+ if cutoff_test(state, depth):
+ return eval_fn(state)
+ v = np.inf
+ for a in game.actions(state):
+ v = min(v, max_value(game.result(state, a), alpha, beta, depth + 1))
+ if v <= alpha:
+ return v
+ beta = min(beta, v)
+ return v
+
+ # Body of alpha_beta_cutoff_search starts here:
+ # The default test cuts off at depth d or at a terminal state
+ cutoff_test = (cutoff_test or (lambda state, depth: depth > d or game.terminal_test(state)))
+ eval_fn = eval_fn or (lambda state: game.utility(state, player))
+ best_score = -np.inf
+ beta = np.inf
+ best_action = None
+ for a in game.actions(state):
+ v = min_value(game.result(state, a), best_score, beta, 1)
+ if v > best_score:
+ best_score = v
+ best_action = a
+ return best_action
+
+
+# ______________________________________________________________________________
+# Monte Carlo Tree Search
+
+
+def monte_carlo_tree_search(state, game, N=1000):
+ def select(n):
+ """select a leaf node in the tree"""
+ if n.children:
+ return select(max(n.children.keys(), key=ucb))
+ else:
+ return n
+
+ def expand(n):
+ """expand the leaf node by adding all its children states"""
+ if not n.children and not game.terminal_test(n.state):
+ n.children = {MCT_Node(state=game.result(n.state, action), parent=n): action
+ for action in game.actions(n.state)}
+ return select(n)
+
+ def simulate(game, state):
+ """simulate the utility of current state by random picking a step"""
+ player = game.to_move(state)
+ while not game.terminal_test(state):
+ action = random.choice(list(game.actions(state)))
+ state = game.result(state, action)
+ v = game.utility(state, player)
+ return -v
+
+ def backprop(n, utility):
+ """passing the utility back to all parent nodes"""
+ if utility > 0:
+ n.U += utility
+ # if utility == 0:
+ # n.U += 0.5
+ n.N += 1
+ if n.parent:
+ backprop(n.parent, -utility)
+
+ root = MCT_Node(state=state)
+
+ for _ in range(N):
+ leaf = select(root)
+ child = expand(leaf)
+ result = simulate(game, child.state)
+ backprop(child, result)
+
+ max_state = max(root.children, key=lambda p: p.N)
+
+ return root.children.get(max_state)
+
+
+# ______________________________________________________________________________
+# Players for Games
+
+
+def query_player(game, state):
+ """Make a move by querying standard input."""
+ print("current state:")
+ game.display(state)
+ print("available moves: {}".format(game.actions(state)))
+ print("")
+ move = None
+ if game.actions(state):
+ move_string = input('Your move? ')
+ try:
+ move = eval(move_string)
+ except NameError:
+ move = move_string
+ else:
+ print('no legal moves: passing turn to next player')
+ return move
+
+
+def random_player(game, state):
+ """A player that chooses a legal move at random."""
+ return random.choice(game.actions(state)) if game.actions(state) else None
+
+
+def alpha_beta_player(game, state):
+ return alpha_beta_search(state, game)
+
+
+def expect_min_max_player(game, state):
+ return expect_minmax(state, game)
+
+
+def mcts_player(game, state):
+ return monte_carlo_tree_search(state, game)
+
+
+# ______________________________________________________________________________
+# Some Sample Games
+
+
+class Game:
+ """A game is similar to a problem, but it has a utility for each
+ state and a terminal test instead of a path cost and a goal
+ test. To create a game, subclass this class and implement actions,
+ result, utility, and terminal_test. You may override display and
+ successors or you can inherit their default methods. You will also
+ need to set the .initial attribute to the initial state; this can
+ be done in the constructor."""
+
+ def actions(self, state):
+ """Return a list of the allowable moves at this point."""
+ raise NotImplementedError
+
+ def result(self, state, move):
+ """Return the state that results from making a move from a state."""
+ raise NotImplementedError
+
+ def utility(self, state, player):
+ """Return the value of this final state to player."""
+ raise NotImplementedError
+
+ def terminal_test(self, state):
+ """Return True if this is a final state for the game."""
+ return not self.actions(state)
+
+ def to_move(self, state):
+ """Return the player whose move it is in this state."""
+ return state.to_move
+
+ def display(self, state):
+ """Print or otherwise display the state."""
+ print(state)
+
+ def __repr__(self):
+ return '<{}>'.format(self.__class__.__name__)
+
+ def play_game(self, *players):
+ """Play an n-person, move-alternating game."""
+ state = self.initial
+ while True:
+ for player in players:
+ move = player(self, state)
+ state = self.result(state, move)
+ if self.terminal_test(state):
+ self.display(state)
+ return self.utility(state, self.to_move(self.initial))
+
+
+class StochasticGame(Game):
+ """A stochastic game includes uncertain events which influence
+ the moves of players at each state. To create a stochastic game, subclass
+ this class and implement chances and outcome along with the other
+ unimplemented game class methods."""
+
+ def chances(self, state):
+ """Return a list of all possible uncertain events at a state."""
+ raise NotImplementedError
+
+ def outcome(self, state, chance):
+ """Return the state which is the outcome of a chance trial."""
+ raise NotImplementedError
+
+ def probability(self, chance):
+ """Return the probability of occurrence of a chance."""
+ raise NotImplementedError
+
+ def play_game(self, *players):
+ """Play an n-person, move-alternating stochastic game."""
+ state = self.initial
+ while True:
+ for player in players:
+ chance = random.choice(self.chances(state))
+ state = self.outcome(state, chance)
+ move = player(self, state)
+ state = self.result(state, move)
+ if self.terminal_test(state):
+ self.display(state)
+ return self.utility(state, self.to_move(self.initial))
+
+
+class Fig52Game(Game):
+ """The game represented in [Figure 5.2]. Serves as a simple test case."""
+
+ succs = dict(A=dict(a1='B', a2='C', a3='D'),
+ B=dict(b1='B1', b2='B2', b3='B3'),
+ C=dict(c1='C1', c2='C2', c3='C3'),
+ D=dict(d1='D1', d2='D2', d3='D3'))
+ utils = dict(B1=3, B2=12, B3=8, C1=2, C2=4, C3=6, D1=14, D2=5, D3=2)
+ initial = 'A'
+
+ def actions(self, state):
+ return list(self.succs.get(state, {}).keys())
+
+ def result(self, state, move):
+ return self.succs[state][move]
+
+ def utility(self, state, player):
+ if player == 'MAX':
+ return self.utils[state]
+ else:
+ return -self.utils[state]
+
+ def terminal_test(self, state):
+ return state not in ('A', 'B', 'C', 'D')
+
+ def to_move(self, state):
+ return 'MIN' if state in 'BCD' else 'MAX'
+
+
+class Fig52Extended(Game):
+ """Similar to Fig52Game but bigger. Useful for visualisation"""
+
+ succs = {i: dict(l=i * 3 + 1, m=i * 3 + 2, r=i * 3 + 3) for i in range(13)}
+ utils = dict()
+
+ def actions(self, state):
+ return sorted(list(self.succs.get(state, {}).keys()))
+
+ def result(self, state, move):
+ return self.succs[state][move]
+
+ def utility(self, state, player):
+ if player == 'MAX':
+ return self.utils[state]
+ else:
+ return -self.utils[state]
+
+ def terminal_test(self, state):
+ return state not in range(13)
+
+ def to_move(self, state):
+ return 'MIN' if state in {1, 2, 3} else 'MAX'
+
+
+class TicTacToe(Game):
+ """Play TicTacToe on an h x v board, with Max (first player) playing 'X'.
+ A state has the player to move, a cached utility, a list of moves in
+ the form of a list of (x, y) positions, and a board, in the form of
+ a dict of {(x, y): Player} entries, where Player is 'X' or 'O'."""
+
+ def __init__(self, h=3, v=3, k=3):
+ self.h = h
+ self.v = v
+ self.k = k
+ moves = [(x, y) for x in range(1, h + 1)
+ for y in range(1, v + 1)]
+ self.initial = GameState(to_move='X', utility=0, board={}, moves=moves)
+
+ def actions(self, state):
+ """Legal moves are any square not yet taken."""
+ return state.moves
+
+ def result(self, state, move):
+ if move not in state.moves:
+ return state # Illegal move has no effect
+ board = state.board.copy()
+ board[move] = state.to_move
+ moves = list(state.moves)
+ moves.remove(move)
+ return GameState(to_move=('O' if state.to_move == 'X' else 'X'),
+ utility=self.compute_utility(board, move, state.to_move),
+ board=board, moves=moves)
+
+ def utility(self, state, player):
+ """Return the value to player; 1 for win, -1 for loss, 0 otherwise."""
+ return state.utility if player == 'X' else -state.utility
+
+ def terminal_test(self, state):
+ """A state is terminal if it is won or there are no empty squares."""
+ return state.utility != 0 or len(state.moves) == 0
+
+ def display(self, state):
+ board = state.board
+ for x in range(1, self.h + 1):
+ for y in range(1, self.v + 1):
+ print(board.get((x, y), '.'), end=' ')
+ print()
+
+ def compute_utility(self, board, move, player):
+ """If 'X' wins with this move, return 1; if 'O' wins return -1; else return 0."""
+ if (self.k_in_row(board, move, player, (0, 1)) or
+ self.k_in_row(board, move, player, (1, 0)) or
+ self.k_in_row(board, move, player, (1, -1)) or
+ self.k_in_row(board, move, player, (1, 1))):
+ return +1 if player == 'X' else -1
+ else:
+ return 0
+
+ def k_in_row(self, board, move, player, delta_x_y):
+ """Return true if there is a line through move on board for player."""
+ (delta_x, delta_y) = delta_x_y
+ x, y = move
+ n = 0 # n is number of moves in row
+ while board.get((x, y)) == player:
+ n += 1
+ x, y = x + delta_x, y + delta_y
+ x, y = move
+ while board.get((x, y)) == player:
+ n += 1
+ x, y = x - delta_x, y - delta_y
+ n -= 1 # Because we counted move itself twice
+ return n >= self.k
+
+
+class ConnectFour(TicTacToe):
+ """A TicTacToe-like game in which you can only make a move on the bottom
+ row, or in a square directly above an occupied square. Traditionally
+ played on a 7x6 board and requiring 4 in a row."""
+
+ def __init__(self, h=7, v=6, k=4):
+ TicTacToe.__init__(self, h, v, k)
+
+ def actions(self, state):
+ return [(x, y) for (x, y) in state.moves
+ if y == 1 or (x, y - 1) in state.board]
+
+
+class Backgammon(StochasticGame):
+ """A two player game where the goal of each player is to move all the
+ checkers off the board. The moves for each state are determined by
+ rolling a pair of dice."""
+
+ def __init__(self):
+ """Initial state of the game"""
+ point = {'W': 0, 'B': 0}
+ board = [point.copy() for index in range(24)]
+ board[0]['B'] = board[23]['W'] = 2
+ board[5]['W'] = board[18]['B'] = 5
+ board[7]['W'] = board[16]['B'] = 3
+ board[11]['B'] = board[12]['W'] = 5
+ self.allow_bear_off = {'W': False, 'B': False}
+ self.direction = {'W': -1, 'B': 1}
+ self.initial = StochasticGameState(to_move='W',
+ utility=0,
+ board=board,
+ moves=self.get_all_moves(board, 'W'), chance=None)
+
+ def actions(self, state):
+ """Return a list of legal moves for a state."""
+ player = state.to_move
+ moves = state.moves
+ if len(moves) == 1 and len(moves[0]) == 1:
+ return moves
+ legal_moves = []
+ for move in moves:
+ board = copy.deepcopy(state.board)
+ if self.is_legal_move(board, move, state.chance, player):
+ legal_moves.append(move)
+ return legal_moves
+
+ def result(self, state, move):
+ board = copy.deepcopy(state.board)
+ player = state.to_move
+ self.move_checker(board, move[0], state.chance[0], player)
+ if len(move) == 2:
+ self.move_checker(board, move[1], state.chance[1], player)
+ to_move = ('W' if player == 'B' else 'B')
+ return StochasticGameState(to_move=to_move,
+ utility=self.compute_utility(board, move, player),
+ board=board,
+ moves=self.get_all_moves(board, to_move), chance=None)
+
+ def utility(self, state, player):
+ """Return the value to player; 1 for win, -1 for loss, 0 otherwise."""
+ return state.utility if player == 'W' else -state.utility
+
+ def terminal_test(self, state):
+ """A state is terminal if one player wins."""
+ return state.utility != 0
+
+ def get_all_moves(self, board, player):
+ """All possible moves for a player i.e. all possible ways of
+ choosing two checkers of a player from the board for a move
+ at a given state."""
+ all_points = board
+ taken_points = [index for index, point in enumerate(all_points)
+ if point[player] > 0]
+ if self.checkers_at_home(board, player) == 1:
+ return [(taken_points[0],)]
+ moves = list(itertools.permutations(taken_points, 2))
+ moves = moves + [(index, index) for index, point in enumerate(all_points)
+ if point[player] >= 2]
+ return moves
+
+ def display(self, state):
+ """Display state of the game."""
+ board = state.board
+ player = state.to_move
+ print("current state : ")
+ for index, point in enumerate(board):
+ print("point : ", index, " W : ", point['W'], " B : ", point['B'])
+ print("to play : ", player)
+
+ def compute_utility(self, board, move, player):
+ """If 'W' wins with this move, return 1; if 'B' wins return -1; else return 0."""
+ util = {'W': 1, 'B': -1}
+ for idx in range(0, 24):
+ if board[idx][player] > 0:
+ return 0
+ return util[player]
+
+ def checkers_at_home(self, board, player):
+ """Return the no. of checkers at home for a player."""
+ sum_range = range(0, 7) if player == 'W' else range(17, 24)
+ count = 0
+ for idx in sum_range:
+ count = count + board[idx][player]
+ return count
+
+ def is_legal_move(self, board, start, steps, player):
+ """Move is a tuple which contains starting points of checkers to be
+ moved during a player's turn. An on-board move is legal if both the destinations
+ are open. A bear-off move is the one where a checker is moved off-board.
+ It is legal only after a player has moved all his checkers to his home."""
+ dest1, dest2 = vector_add(start, steps)
+ dest_range = range(0, 24)
+ move1_legal = move2_legal = False
+ if dest1 in dest_range:
+ if self.is_point_open(player, board[dest1]):
+ self.move_checker(board, start[0], steps[0], player)
+ move1_legal = True
+ else:
+ if self.allow_bear_off[player]:
+ self.move_checker(board, start[0], steps[0], player)
+ move1_legal = True
+ if not move1_legal:
+ return False
+ if dest2 in dest_range:
+ if self.is_point_open(player, board[dest2]):
+ move2_legal = True
+ else:
+ if self.allow_bear_off[player]:
+ move2_legal = True
+ return move1_legal and move2_legal
+
+ def move_checker(self, board, start, steps, player):
+ """Move a checker from starting point by a given number of steps"""
+ dest = start + steps
+ dest_range = range(0, 24)
+ board[start][player] -= 1
+ if dest in dest_range:
+ board[dest][player] += 1
+ if self.checkers_at_home(board, player) == 15:
+ self.allow_bear_off[player] = True
+
+ def is_point_open(self, player, point):
+ """A point is open for a player if the no. of opponent's
+ checkers already present on it is 0 or 1. A player can
+ move a checker to a point only if it is open."""
+ opponent = 'B' if player == 'W' else 'W'
+ return point[opponent] <= 1
+
+ def chances(self, state):
+ """Return a list of all possible dice rolls at a state."""
+ dice_rolls = list(itertools.combinations_with_replacement([1, 2, 3, 4, 5, 6], 2))
+ return dice_rolls
+
+ def outcome(self, state, chance):
+ """Return the state which is the outcome of a dice roll."""
+ dice = tuple(map((self.direction[state.to_move]).__mul__, chance))
+ return StochasticGameState(to_move=state.to_move,
+ utility=state.utility,
+ board=state.board,
+ moves=state.moves, chance=dice)
+
+ def probability(self, chance):
+ """Return the probability of occurrence of a dice roll."""
+ return 1 / 36 if chance[0] == chance[1] else 1 / 18
diff --git a/gui/eight_puzzle.py b/gui/eight_puzzle.py
new file mode 100644
index 000000000..5733228d7
--- /dev/null
+++ b/gui/eight_puzzle.py
@@ -0,0 +1,151 @@
+import os.path
+import random
+import time
+from functools import partial
+from tkinter import *
+
+from search import astar_search, EightPuzzle
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+root = Tk()
+
+state = [1, 2, 3, 4, 5, 6, 7, 8, 0]
+puzzle = EightPuzzle(tuple(state))
+solution = None
+
+b = [None] * 9
+
+
+# TODO: refactor into OOP, remove global variables
+
+def scramble():
+ """Scrambles the puzzle starting from the goal state"""
+
+ global state
+ global puzzle
+ possible_actions = ['UP', 'DOWN', 'LEFT', 'RIGHT']
+ scramble = []
+ for _ in range(60):
+ scramble.append(random.choice(possible_actions))
+
+ for move in scramble:
+ if move in puzzle.actions(state):
+ state = list(puzzle.result(state, move))
+ puzzle = EightPuzzle(tuple(state))
+ create_buttons()
+
+
+def solve():
+ """Solves the puzzle using astar_search"""
+
+ return astar_search(puzzle).solution()
+
+
+def solve_steps():
+ """Solves the puzzle step by step"""
+
+ global puzzle
+ global solution
+ global state
+ solution = solve()
+ print(solution)
+
+ for move in solution:
+ state = puzzle.result(state, move)
+ create_buttons()
+ root.update()
+ root.after(1, time.sleep(0.75))
+
+
+def exchange(index):
+ """Interchanges the position of the selected tile with the zero tile under certain conditions"""
+
+ global state
+ global solution
+ global puzzle
+ zero_ix = list(state).index(0)
+ actions = puzzle.actions(state)
+ current_action = ''
+ i_diff = index // 3 - zero_ix // 3
+ j_diff = index % 3 - zero_ix % 3
+ if i_diff == 1:
+ current_action += 'DOWN'
+ elif i_diff == -1:
+ current_action += 'UP'
+
+ if j_diff == 1:
+ current_action += 'RIGHT'
+ elif j_diff == -1:
+ current_action += 'LEFT'
+
+ if abs(i_diff) + abs(j_diff) != 1:
+ current_action = ''
+
+ if current_action in actions:
+ b[zero_ix].grid_forget()
+ b[zero_ix] = Button(root, text=f'{state[index]}', width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, zero_ix))
+ b[zero_ix].grid(row=zero_ix // 3, column=zero_ix % 3, ipady=40)
+ b[index].grid_forget()
+ b[index] = Button(root, text=None, width=6, font=('Helvetica', 40, 'bold'), command=partial(exchange, index))
+ b[index].grid(row=index // 3, column=index % 3, ipady=40)
+ state[zero_ix], state[index] = state[index], state[zero_ix]
+ puzzle = EightPuzzle(tuple(state))
+
+
+def create_buttons():
+ """Creates dynamic buttons"""
+
+ # TODO: Find a way to use grid_forget() with a for loop for initialization
+ b[0] = Button(root, text=f'{state[0]}' if state[0] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 0))
+ b[0].grid(row=0, column=0, ipady=40)
+ b[1] = Button(root, text=f'{state[1]}' if state[1] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 1))
+ b[1].grid(row=0, column=1, ipady=40)
+ b[2] = Button(root, text=f'{state[2]}' if state[2] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 2))
+ b[2].grid(row=0, column=2, ipady=40)
+ b[3] = Button(root, text=f'{state[3]}' if state[3] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 3))
+ b[3].grid(row=1, column=0, ipady=40)
+ b[4] = Button(root, text=f'{state[4]}' if state[4] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 4))
+ b[4].grid(row=1, column=1, ipady=40)
+ b[5] = Button(root, text=f'{state[5]}' if state[5] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 5))
+ b[5].grid(row=1, column=2, ipady=40)
+ b[6] = Button(root, text=f'{state[6]}' if state[6] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 6))
+ b[6].grid(row=2, column=0, ipady=40)
+ b[7] = Button(root, text=f'{state[7]}' if state[7] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 7))
+ b[7].grid(row=2, column=1, ipady=40)
+ b[8] = Button(root, text=f'{state[8]}' if state[8] != 0 else None, width=6, font=('Helvetica', 40, 'bold'),
+ command=partial(exchange, 8))
+ b[8].grid(row=2, column=2, ipady=40)
+
+
+def create_static_buttons():
+ """Creates scramble and solve buttons"""
+
+ scramble_btn = Button(root, text='Scramble', font=('Helvetica', 30, 'bold'), width=8, command=partial(init))
+ scramble_btn.grid(row=3, column=0, ipady=10)
+ solve_btn = Button(root, text='Solve', font=('Helvetica', 30, 'bold'), width=8, command=partial(solve_steps))
+ solve_btn.grid(row=3, column=2, ipady=10)
+
+
+def init():
+ """Calls necessary functions"""
+
+ global state
+ global solution
+ state = [1, 2, 3, 4, 5, 6, 7, 8, 0]
+ scramble()
+ create_buttons()
+ create_static_buttons()
+
+
+init()
+root.mainloop()
diff --git a/gui/genetic_algorithm_example.py b/gui/genetic_algorithm_example.py
index 418da02e9..c987151c8 100644
--- a/gui/genetic_algorithm_example.py
+++ b/gui/genetic_algorithm_example.py
@@ -1,4 +1,3 @@
-# author: ad71
# A simple program that implements the solution to the phrase generation problem using
# genetic algorithms as given in the search.ipynb notebook.
#
@@ -9,17 +8,13 @@
# Displays a progress bar that indicates the amount of completion of the algorithm
# Displays the first few individuals of the current generation
-import sys
-import time
-import random
import os.path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-
from tkinter import *
from tkinter import ttk
import search
-from utils import argmax
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
LARGE_FONT = ('Verdana', 12)
EXTRA_LARGE_FONT = ('Consolas', 36, 'bold')
@@ -34,20 +29,20 @@
# genetic algorithm variables
# feel free to play around with these
-target = 'Genetic Algorithm' # the phrase to be generated
-max_population = 100 # number of samples in each population
-mutation_rate = 0.1 # probability of mutation
-f_thres = len(target) # fitness threshold
-ngen = 1200 # max number of generations to run the genetic algorithm
+target = 'Genetic Algorithm' # the phrase to be generated
+max_population = 100 # number of samples in each population
+mutation_rate = 0.1 # probability of mutation
+f_thres = len(target) # fitness threshold
+ngen = 1200 # max number of generations to run the genetic algorithm
-generation = 0 # counter to keep track of generation number
+generation = 0 # counter to keep track of generation number
-u_case = [chr(x) for x in range(65, 91)] # list containing all uppercase characters
-l_case = [chr(x) for x in range(97, 123)] # list containing all lowercase characters
-punctuations1 = [chr(x) for x in range(33, 48)] # lists containing punctuation symbols
+u_case = [chr(x) for x in range(65, 91)] # list containing all uppercase characters
+l_case = [chr(x) for x in range(97, 123)] # list containing all lowercase characters
+punctuations1 = [chr(x) for x in range(33, 48)] # lists containing punctuation symbols
punctuations2 = [chr(x) for x in range(58, 65)]
punctuations3 = [chr(x) for x in range(91, 97)]
-numerals = [chr(x) for x in range(48, 58)] # list containing numbers
+numerals = [chr(x) for x in range(48, 58)] # list containing numbers
# extend the gene pool with the required lists and append the space character
gene_pool = []
@@ -55,44 +50,51 @@
gene_pool.extend(l_case)
gene_pool.append(' ')
+
# callbacks to update global variables from the slider values
def update_max_population(slider_value):
- global max_population
- max_population = slider_value
+ global max_population
+ max_population = slider_value
+
def update_mutation_rate(slider_value):
- global mutation_rate
- mutation_rate = slider_value
+ global mutation_rate
+ mutation_rate = slider_value
+
def update_f_thres(slider_value):
- global f_thres
- f_thres = slider_value
+ global f_thres
+ f_thres = slider_value
+
def update_ngen(slider_value):
- global ngen
- ngen = slider_value
+ global ngen
+ ngen = slider_value
+
# fitness function
def fitness_fn(_list):
- fitness = 0
- # create string from list of characters
- phrase = ''.join(_list)
- # add 1 to fitness value for every matching character
- for i in range(len(phrase)):
- if target[i] == phrase[i]:
- fitness += 1
- return fitness
+ fitness = 0
+ # create string from list of characters
+ phrase = ''.join(_list)
+ # add 1 to fitness value for every matching character
+ for i in range(len(phrase)):
+ if target[i] == phrase[i]:
+ fitness += 1
+ return fitness
+
# function to bring a new frame on top
def raise_frame(frame, init=False, update_target=False, target_entry=None, f_thres_slider=None):
- frame.tkraise()
- global target
- if update_target and target_entry is not None:
- target = target_entry.get()
- f_thres_slider.config(to=len(target))
- if init:
- population = search.init_population(max_population, gene_pool, len(target))
- genetic_algorithm_stepwise(population)
+ frame.tkraise()
+ global target
+ if update_target and target_entry is not None:
+ target = target_entry.get()
+ f_thres_slider.config(to=len(target))
+ if init:
+ population = search.init_population(max_population, gene_pool, len(target))
+ genetic_algorithm_stepwise(population)
+
# defining root and child frames
root = Tk()
@@ -101,7 +103,7 @@ def raise_frame(frame, init=False, update_target=False, target_entry=None, f_thr
# pack frames on top of one another
for frame in (f1, f2):
- frame.grid(row=0, column=0, sticky='news')
+ frame.grid(row=0, column=0, sticky='news')
# Home Screen (f1) widgets
target_entry = Entry(f1, font=('Consolas 46 bold'), exportselection=0, foreground=p_blue, justify=CENTER)
@@ -109,64 +111,79 @@ def raise_frame(frame, init=False, update_target=False, target_entry=None, f_thr
target_entry.pack(expand=YES, side=TOP, fill=X, padx=50)
target_entry.focus_force()
-max_population_slider = Scale(f1, from_=3, to=1000, orient=HORIZONTAL, label='Max population', command=lambda value: update_max_population(int(value)))
+max_population_slider = Scale(f1, from_=3, to=1000, orient=HORIZONTAL, label='Max population',
+ command=lambda value: update_max_population(int(value)))
max_population_slider.set(max_population)
max_population_slider.pack(expand=YES, side=TOP, fill=X, padx=40)
-mutation_rate_slider = Scale(f1, from_=0, to=1, orient=HORIZONTAL, label='Mutation rate', resolution=0.0001, command=lambda value: update_mutation_rate(float(value)))
+mutation_rate_slider = Scale(f1, from_=0, to=1, orient=HORIZONTAL, label='Mutation rate', resolution=0.0001,
+ command=lambda value: update_mutation_rate(float(value)))
mutation_rate_slider.set(mutation_rate)
mutation_rate_slider.pack(expand=YES, side=TOP, fill=X, padx=40)
-f_thres_slider = Scale(f1, from_=0, to=len(target), orient=HORIZONTAL, label='Fitness threshold', command=lambda value: update_f_thres(int(value)))
+f_thres_slider = Scale(f1, from_=0, to=len(target), orient=HORIZONTAL, label='Fitness threshold',
+ command=lambda value: update_f_thres(int(value)))
f_thres_slider.set(f_thres)
f_thres_slider.pack(expand=YES, side=TOP, fill=X, padx=40)
-ngen_slider = Scale(f1, from_=1, to=5000, orient=HORIZONTAL, label='Max number of generations', command=lambda value: update_ngen(int(value)))
+ngen_slider = Scale(f1, from_=1, to=5000, orient=HORIZONTAL, label='Max number of generations',
+ command=lambda value: update_ngen(int(value)))
ngen_slider.set(ngen)
ngen_slider.pack(expand=YES, side=TOP, fill=X, padx=40)
-button = ttk.Button(f1, text='RUN', command=lambda: raise_frame(f2, init=True, update_target=True, target_entry=target_entry, f_thres_slider=f_thres_slider)).pack(side=BOTTOM, pady=50)
+button = ttk.Button(f1, text='RUN',
+ command=lambda: raise_frame(f2, init=True, update_target=True, target_entry=target_entry,
+ f_thres_slider=f_thres_slider)).pack(side=BOTTOM, pady=50)
# f2 widgets
canvas = Canvas(f2, width=canvas_width, height=canvas_height)
canvas.pack(expand=YES, fill=BOTH, padx=20, pady=15)
button = ttk.Button(f2, text='EXIT', command=lambda: raise_frame(f1)).pack(side=BOTTOM, pady=15)
+
# function to run the genetic algorithm and update text on the canvas
def genetic_algorithm_stepwise(population):
- root.title('Genetic Algorithm')
- for generation in range(ngen):
- # generating new population after selecting, recombining and mutating the existing population
- population = [search.mutate(search.recombine(*search.select(2, population, fitness_fn)), gene_pool, mutation_rate) for i in range(len(population))]
- # genome with the highest fitness in the current generation
- current_best = ''.join(argmax(population, key=fitness_fn))
- # collecting first few examples from the current population
- members = [''.join(x) for x in population][:48]
-
- # clear the canvas
- canvas.delete('all')
- # displays current best on top of the screen
- canvas.create_text(canvas_width / 2, 40, fill=p_blue, font='Consolas 46 bold', text=current_best)
-
- # displaying a part of the population on the screen
- for i in range(len(members) // 3):
- canvas.create_text((canvas_width * .175), (canvas_height * .25 + (25 * i)), fill=lp_blue, font='Consolas 16', text=members[3 * i])
- canvas.create_text((canvas_width * .500), (canvas_height * .25 + (25 * i)), fill=lp_blue, font='Consolas 16', text=members[3 * i + 1])
- canvas.create_text((canvas_width * .825), (canvas_height * .25 + (25 * i)), fill=lp_blue, font='Consolas 16', text=members[3 * i + 2])
-
- # displays current generation number
- canvas.create_text((canvas_width * .5), (canvas_height * 0.95), fill=p_blue, font='Consolas 18 bold', text=f'Generation {generation}')
-
- # displays blue bar that indicates current maximum fitness compared to maximum possible fitness
- scaling_factor = fitness_fn(current_best) / len(target)
- canvas.create_rectangle(canvas_width * 0.1, 90, canvas_width * 0.9, 100, outline=p_blue)
- canvas.create_rectangle(canvas_width * 0.1, 90, canvas_width * 0.1 + scaling_factor * canvas_width * 0.8, 100, fill=lp_blue)
- canvas.update()
-
- # checks for completion
- fittest_individual = search.fitness_threshold(fitness_fn, f_thres, population)
- if fittest_individual:
- break
+ root.title('Genetic Algorithm')
+ for generation in range(ngen):
+ # generating new population after selecting, recombining and mutating the existing population
+ population = [
+ search.mutate(search.recombine(*search.select(2, population, fitness_fn)), gene_pool, mutation_rate) for i
+ in range(len(population))]
+ # genome with the highest fitness in the current generation
+ current_best = ''.join(max(population, key=fitness_fn))
+ # collecting first few examples from the current population
+ members = [''.join(x) for x in population][:48]
+
+ # clear the canvas
+ canvas.delete('all')
+ # displays current best on top of the screen
+ canvas.create_text(canvas_width / 2, 40, fill=p_blue, font='Consolas 46 bold', text=current_best)
+
+ # displaying a part of the population on the screen
+ for i in range(len(members) // 3):
+ canvas.create_text((canvas_width * .175), (canvas_height * .25 + (25 * i)), fill=lp_blue,
+ font='Consolas 16', text=members[3 * i])
+ canvas.create_text((canvas_width * .500), (canvas_height * .25 + (25 * i)), fill=lp_blue,
+ font='Consolas 16', text=members[3 * i + 1])
+ canvas.create_text((canvas_width * .825), (canvas_height * .25 + (25 * i)), fill=lp_blue,
+ font='Consolas 16', text=members[3 * i + 2])
+
+ # displays current generation number
+ canvas.create_text((canvas_width * .5), (canvas_height * 0.95), fill=p_blue, font='Consolas 18 bold',
+ text=f'Generation {generation}')
+
+ # displays blue bar that indicates current maximum fitness compared to maximum possible fitness
+ scaling_factor = fitness_fn(current_best) / len(target)
+ canvas.create_rectangle(canvas_width * 0.1, 90, canvas_width * 0.9, 100, outline=p_blue)
+ canvas.create_rectangle(canvas_width * 0.1, 90, canvas_width * 0.1 + scaling_factor * canvas_width * 0.8, 100,
+ fill=lp_blue)
+ canvas.update()
+
+ # checks for completion
+ fittest_individual = search.fitness_threshold(fitness_fn, f_thres, population)
+ if fittest_individual:
+ break
+
raise_frame(f1)
-root.mainloop()
\ No newline at end of file
+root.mainloop()
diff --git a/gui/grid_mdp.py b/gui/grid_mdp.py
index fd5aeb8ae..e60b49247 100644
--- a/gui/grid_mdp.py
+++ b/gui/grid_mdp.py
@@ -1,26 +1,22 @@
-# author: ad71
+import os.path
+import sys
import tkinter as tk
import tkinter.messagebox
-from tkinter import ttk
-
from functools import partial
-
-import sys
-import os.path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-
-from mdp import *
-import utils
-import numpy as np
-import time
+from tkinter import ttk
import matplotlib
import matplotlib.animation as animation
+from matplotlib import pyplot as plt
+from matplotlib import style
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
-from matplotlib.ticker import MaxNLocator
from matplotlib.figure import Figure
-from matplotlib import style
-from matplotlib import pyplot as plt
+from matplotlib.ticker import MaxNLocator
+
+from mdp import *
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
matplotlib.use('TkAgg')
style.use('ggplot')
@@ -41,589 +37,640 @@
green8 = '#008080'
green4 = '#004040'
+cell_window_mantainer = None
-def extents(f):
- ''' adjusts axis markers for heatmap '''
-
- delta = f[1] - f[0]
- return [f[0] - delta/2, f[-1] + delta/2]
-def display(gridmdp, _height, _width):
- ''' displays matrix '''
-
- dialog = tk.Toplevel()
- dialog.wm_title('Values')
-
- container = tk.Frame(dialog)
- container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
-
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- label = ttk.Label(container, text=f'{gridmdp[_height - i - 1][j]:.3f}', font=('Helvetica', 12))
- label.grid(row=i + 1, column=j + 1, padx=3, pady=3)
-
- dialog.mainloop()
-
-def initialize_dialogbox(_width, _height, gridmdp, terminals, buttons):
- ''' creates dialogbox for initialization '''
-
- dialog = tk.Toplevel()
- dialog.wm_title('Initialize')
-
- container = tk.Frame(dialog)
- container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
- container.grid_rowconfigure(0, weight=1)
- container.grid_columnconfigure(0, weight=1)
-
- wall = tk.IntVar()
- wall.set(0)
- term = tk.IntVar()
- term.set(0)
- reward = tk.DoubleVar()
- reward.set(0.0)
-
- label = ttk.Label(container, text='Initialize', font=('Helvetica', 12), anchor=tk.N)
- label.grid(row=0, column=0, columnspan=3, sticky='new', pady=15, padx=5)
- label_reward = ttk.Label(container, text='Reward', font=('Helvetica', 10), anchor=tk.N)
- label_reward.grid(row=1, column=0, columnspan=3, sticky='new', pady=1, padx=5)
- entry_reward = ttk.Entry(container, font=('Helvetica', 10), justify=tk.CENTER, exportselection=0, textvariable=reward)
- entry_reward.grid(row=2, column=0, columnspan=3, sticky='new', pady=5, padx=50)
-
- rbtn_term = ttk.Radiobutton(container, text='Terminal', variable=term, value=TERM_VALUE)
- rbtn_term.grid(row=3, column=0, columnspan=3, sticky='nsew', padx=160, pady=5)
- rbtn_wall = ttk.Radiobutton(container, text='Wall', variable=wall, value=WALL_VALUE)
- rbtn_wall.grid(row=4, column=0, columnspan=3, sticky='nsew', padx=172, pady=5)
-
- initialize_widget_disability_checks(_width, _height, gridmdp, terminals, label_reward, entry_reward, rbtn_wall, rbtn_term)
-
- btn_apply = ttk.Button(container, text='Apply', command=partial(initialize_update_table, _width, _height, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term, rbtn_wall))
- btn_apply.grid(row=5, column=0, sticky='nsew', pady=5, padx=5)
- btn_reset = ttk.Button(container, text='Reset', command=partial(initialize_reset_all, _width, _height, gridmdp, terminals, buttons, label_reward, entry_reward, rbtn_wall, rbtn_term))
- btn_reset.grid(row=5, column=1, sticky='nsew', pady=5, padx=5)
- btn_ok = ttk.Button(container, text='Ok', command=dialog.destroy)
- btn_ok.grid(row=5, column=2, sticky='nsew', pady=5, padx=5)
-
- dialog.geometry('400x200')
- dialog.mainloop()
-
-def update_table(i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term, rbtn_wall):
- ''' functionality for 'apply' button '''
-
- if wall.get() == WALL_VALUE:
- buttons[i][j].configure(style='wall.TButton')
- buttons[i][j].config(text='Wall')
- label_reward.config(foreground='#999')
- entry_reward.config(state=tk.DISABLED)
- rbtn_term.state(['!focus', '!selected'])
- rbtn_term.config(state=tk.DISABLED)
- gridmdp[i][j] = WALL_VALUE
-
- elif wall.get() != WALL_VALUE:
- if reward.get() != 0.0:
- gridmdp[i][j] = reward.get()
- buttons[i][j].configure(style='reward.TButton')
- buttons[i][j].config(text=f'R = {reward.get()}')
-
- if term.get() == TERM_VALUE:
- if (i, j) not in terminals:
- terminals.append((i, j))
- rbtn_wall.state(['!focus', '!selected'])
- rbtn_wall.config(state=tk.DISABLED)
-
- if gridmdp[i][j] < 0:
- buttons[i][j].configure(style='-term.TButton')
-
- elif gridmdp[i][j] > 0:
- buttons[i][j].configure(style='+term.TButton')
-
- elif gridmdp[i][j] == 0.0:
- buttons[i][j].configure(style='=term.TButton')
-
-def initialize_update_table(_width, _height, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term, rbtn_wall):
- ''' runs update_table for all cells '''
-
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- update_table(i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term, rbtn_wall)
-
-def reset_all(_height, i, j, gridmdp, terminals, buttons, label_reward, entry_reward, rbtn_wall, rbtn_term):
- ''' functionality for reset button '''
-
- gridmdp[i][j] = 0.0
- buttons[i][j].configure(style='TButton')
- buttons[i][j].config(text=f'({_height - i - 1}, {j})')
-
- if (i, j) in terminals:
- terminals.remove((i, j))
-
- label_reward.config(foreground='#000')
- entry_reward.config(state=tk.NORMAL)
- rbtn_term.config(state=tk.NORMAL)
- rbtn_wall.config(state=tk.NORMAL)
- rbtn_wall.state(['!focus', '!selected'])
- rbtn_term.state(['!focus', '!selected'])
-
-def initialize_reset_all(_width, _height, gridmdp, terminals, buttons, label_reward, entry_reward, rbtn_wall, rbtn_term):
- ''' runs reset_all for all cells '''
-
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- reset_all(_height, i, j, gridmdp, terminals, buttons, label_reward, entry_reward, rbtn_wall, rbtn_term)
-
-def external_reset(_width, _height, gridmdp, terminals, buttons):
- ''' reset from edit menu '''
-
- terminals = []
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- gridmdp[i][j] = 0.0
- buttons[i][j].configure(style='TButton')
- buttons[i][j].config(text=f'({_height - i - 1}, {j})')
-
-def widget_disability_checks(i, j, gridmdp, terminals, label_reward, entry_reward, rbtn_wall, rbtn_term):
- ''' checks for required state of widgets in dialogboxes '''
-
- if gridmdp[i][j] == WALL_VALUE:
- label_reward.config(foreground='#999')
- entry_reward.config(state=tk.DISABLED)
- rbtn_term.config(state=tk.DISABLED)
- rbtn_wall.state(['!focus', 'selected'])
- rbtn_term.state(['!focus', '!selected'])
-
- if (i, j) in terminals:
- rbtn_wall.config(state=tk.DISABLED)
- rbtn_wall.state(['!focus', '!selected'])
-
-def flatten_list(_list):
- ''' returns a flattened list '''
-
- return sum(_list, [])
-
-def initialize_widget_disability_checks(_width, _height, gridmdp, terminals, label_reward, entry_reward, rbtn_wall, rbtn_term):
- ''' checks for required state of widgets when cells are initialized '''
-
- bool_walls = [['False']*max(1, _width) for _ in range(max(1, _height))]
- bool_terms = [['False']*max(1, _width) for _ in range(max(1, _height))]
-
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- if gridmdp[i][j] == WALL_VALUE:
- bool_walls[i][j] = 'True'
-
- if (i, j) in terminals:
- bool_terms[i][j] = 'True'
-
- bool_walls_fl = flatten_list(bool_walls)
- bool_terms_fl = flatten_list(bool_terms)
-
- if bool_walls_fl.count('True') == len(bool_walls_fl):
- print('`')
- label_reward.config(foreground='#999')
- entry_reward.config(state=tk.DISABLED)
- rbtn_term.config(state=tk.DISABLED)
- rbtn_wall.state(['!focus', 'selected'])
- rbtn_term.state(['!focus', '!selected'])
-
- if bool_terms_fl.count('True') == len(bool_terms_fl):
- rbtn_wall.config(state=tk.DISABLED)
- rbtn_wall.state(['!focus', '!selected'])
- rbtn_term.state(['!focus', 'selected'])
-
-def dialogbox(i, j, gridmdp, terminals, buttons, _height):
- ''' creates dialogbox for each cell '''
-
- dialog = tk.Toplevel()
- dialog.wm_title(f'{_height - i - 1}, {j}')
+def extents(f):
+ """adjusts axis markers for heatmap"""
- container = tk.Frame(dialog)
- container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
- container.grid_rowconfigure(0, weight=1)
- container.grid_columnconfigure(0, weight=1)
+ delta = f[1] - f[0]
+ return [f[0] - delta / 2, f[-1] + delta / 2]
- wall = tk.IntVar()
- wall.set(gridmdp[i][j])
- term = tk.IntVar()
- term.set(TERM_VALUE if (i, j) in terminals else 0.0)
- reward = tk.DoubleVar()
- reward.set(gridmdp[i][j] if gridmdp[i][j] != WALL_VALUE else 0.0)
- label = ttk.Label(container, text=f'Configure cell {_height - i - 1}, {j}', font=('Helvetica', 12), anchor=tk.N)
- label.grid(row=0, column=0, columnspan=3, sticky='new', pady=15, padx=5)
- label_reward = ttk.Label(container, text='Reward', font=('Helvetica', 10), anchor=tk.N)
- label_reward.grid(row=1, column=0, columnspan=3, sticky='new', pady=1, padx=5)
- entry_reward = ttk.Entry(container, font=('Helvetica', 10), justify=tk.CENTER, exportselection=0, textvariable=reward)
- entry_reward.grid(row=2, column=0, columnspan=3, sticky='new', pady=5, padx=50)
+def display(gridmdp, _height, _width):
+ """displays matrix"""
- rbtn_term = ttk.Radiobutton(container, text='Terminal', variable=term, value=TERM_VALUE)
- rbtn_term.grid(row=3, column=0, columnspan=3, sticky='nsew', padx=160, pady=5)
- rbtn_wall = ttk.Radiobutton(container, text='Wall', variable=wall, value=WALL_VALUE)
- rbtn_wall.grid(row=4, column=0, columnspan=3, sticky='nsew', padx=172, pady=5)
+ dialog = tk.Toplevel()
+ dialog.wm_title('Values')
- widget_disability_checks(i, j, gridmdp, terminals, label_reward, entry_reward, rbtn_wall, rbtn_term)
+ container = tk.Frame(dialog)
+ container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
- btn_apply = ttk.Button(container, text='Apply', command=partial(update_table, i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term, rbtn_wall))
- btn_apply.grid(row=5, column=0, sticky='nsew', pady=5, padx=5)
- btn_reset = ttk.Button(container, text='Reset', command=partial(reset_all, _height, i, j, gridmdp, terminals, buttons, label_reward, entry_reward, rbtn_wall, rbtn_term))
- btn_reset.grid(row=5, column=1, sticky='nsew', pady=5, padx=5)
- btn_ok = ttk.Button(container, text='Ok', command=dialog.destroy)
- btn_ok.grid(row=5, column=2, sticky='nsew', pady=5, padx=5)
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ label = ttk.Label(container, text=f'{gridmdp[_height - i - 1][j]:.3f}', font=('Helvetica', 12))
+ label.grid(row=i + 1, column=j + 1, padx=3, pady=3)
- dialog.geometry('400x200')
- dialog.mainloop()
+ dialog.mainloop()
-class MDPapp(tk.Tk):
+def display_best_policy(_best_policy, _height, _width):
+ """displays best policy"""
+ dialog = tk.Toplevel()
+ dialog.wm_title('Best Policy')
- def __init__(self, *args, **kwargs):
+ container = tk.Frame(dialog)
+ container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
- tk.Tk.__init__(self, *args, **kwargs)
- tk.Tk.wm_title(self, 'Grid MDP')
- self.shared_data = {
- 'height': tk.IntVar(),
- 'width': tk.IntVar()
- }
- self.shared_data['height'].set(1)
- self.shared_data['width'].set(1)
- self.container = tk.Frame(self)
- self.container.pack(side='top', fill='both', expand=True)
- self.container.grid_rowconfigure(0, weight=1)
- self.container.grid_columnconfigure(0, weight=1)
-
- self.frames = {}
-
- self.menu_bar = tk.Menu(self.container)
- self.file_menu = tk.Menu(self.menu_bar, tearoff=0)
- self.file_menu.add_command(label='Exit', command=self.exit)
- self.menu_bar.add_cascade(label='File', menu=self.file_menu)
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ label = ttk.Label(container, text=_best_policy[i][j], font=('Helvetica', 12, 'bold'))
+ label.grid(row=i + 1, column=j + 1, padx=3, pady=3)
- self.edit_menu = tk.Menu(self.menu_bar, tearoff=1)
- self.edit_menu.add_command(label='Reset', command=self.master_reset)
- self.edit_menu.add_command(label='Initialize', command=self.initialize)
- self.edit_menu.add_separator()
- self.edit_menu.add_command(label='View matrix', command=self.view_matrix)
- self.edit_menu.add_command(label='View terminals', command=self.view_terminals)
- self.menu_bar.add_cascade(label='Edit', menu=self.edit_menu)
- self.menu_bar.entryconfig('Edit', state=tk.DISABLED)
+ dialog.mainloop()
- self.build_menu = tk.Menu(self.menu_bar, tearoff=1)
- self.build_menu.add_command(label='Build and Run', command=self.build)
- self.menu_bar.add_cascade(label='Build', menu=self.build_menu)
- self.menu_bar.entryconfig('Build', state=tk.DISABLED)
- tk.Tk.config(self, menu=self.menu_bar)
- for F in (HomePage, BuildMDP, SolveMDP):
- frame = F(self.container, self)
- self.frames[F] = frame
- frame.grid(row=0, column=0, sticky='nsew')
+def initialize_dialogbox(_width, _height, gridmdp, terminals, buttons):
+ """creates dialogbox for initialization"""
+
+ dialog = tk.Toplevel()
+ dialog.wm_title('Initialize')
+
+ container = tk.Frame(dialog)
+ container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+ container.grid_rowconfigure(0, weight=1)
+ container.grid_columnconfigure(0, weight=1)
+
+ wall = tk.IntVar()
+ wall.set(0)
+ term = tk.IntVar()
+ term.set(0)
+ reward = tk.DoubleVar()
+ reward.set(0.0)
+
+ label = ttk.Label(container, text='Initialize', font=('Helvetica', 12), anchor=tk.N)
+ label.grid(row=0, column=0, columnspan=3, sticky='new', pady=15, padx=5)
+ label_reward = ttk.Label(container, text='Reward', font=('Helvetica', 10), anchor=tk.N)
+ label_reward.grid(row=1, column=0, columnspan=3, sticky='new', pady=1, padx=5)
+ entry_reward = ttk.Entry(container, font=('Helvetica', 10), justify=tk.CENTER, exportselection=0,
+ textvariable=reward)
+ entry_reward.grid(row=2, column=0, columnspan=3, sticky='new', pady=5, padx=50)
+
+ rbtn_term = ttk.Radiobutton(container, text='Terminal', variable=term, value=TERM_VALUE)
+ rbtn_term.grid(row=3, column=0, columnspan=3, sticky='nsew', padx=160, pady=5)
+ rbtn_wall = ttk.Radiobutton(container, text='Wall', variable=wall, value=WALL_VALUE)
+ rbtn_wall.grid(row=4, column=0, columnspan=3, sticky='nsew', padx=172, pady=5)
+
+ initialize_widget_disability_checks(_width, _height, gridmdp, terminals, label_reward, entry_reward, rbtn_wall,
+ rbtn_term)
+
+ btn_apply = ttk.Button(container, text='Apply',
+ command=partial(initialize_update_table, _width, _height, gridmdp, terminals, buttons,
+ reward, term, wall, label_reward, entry_reward, rbtn_term, rbtn_wall))
+ btn_apply.grid(row=5, column=0, sticky='nsew', pady=5, padx=5)
+ btn_reset = ttk.Button(container, text='Reset',
+ command=partial(initialize_reset_all, _width, _height, gridmdp, terminals, buttons, reward,
+ term, wall, label_reward, entry_reward, rbtn_wall, rbtn_term))
+ btn_reset.grid(row=5, column=1, sticky='nsew', pady=5, padx=5)
+ btn_ok = ttk.Button(container, text='Ok', command=dialog.destroy)
+ btn_ok.grid(row=5, column=2, sticky='nsew', pady=5, padx=5)
+
+ dialog.geometry('400x200')
+ dialog.mainloop()
+
+
+def update_table(i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term,
+ rbtn_wall):
+ """functionality for 'apply' button"""
+ if wall.get() == WALL_VALUE:
+ buttons[i][j].configure(style='wall.TButton')
+ buttons[i][j].config(text='Wall')
+ label_reward.config(foreground='#999')
+ entry_reward.config(state=tk.DISABLED)
+ rbtn_term.state(['!focus', '!selected'])
+ rbtn_term.config(state=tk.DISABLED)
+ gridmdp[i][j] = WALL_VALUE
+
+ elif wall.get() != WALL_VALUE:
+ if reward.get() != 0.0:
+ gridmdp[i][j] = reward.get()
+ buttons[i][j].configure(style='reward.TButton')
+ buttons[i][j].config(text=f'R = {reward.get()}')
+
+ if term.get() == TERM_VALUE:
+ if (i, j) not in terminals:
+ terminals.append((i, j))
+ rbtn_wall.state(['!focus', '!selected'])
+ rbtn_wall.config(state=tk.DISABLED)
+
+ if gridmdp[i][j] < 0:
+ buttons[i][j].configure(style='-term.TButton')
+
+ elif gridmdp[i][j] > 0:
+ buttons[i][j].configure(style='+term.TButton')
+
+ elif gridmdp[i][j] == 0.0:
+ buttons[i][j].configure(style='=term.TButton')
+
+
+def initialize_update_table(_width, _height, gridmdp, terminals, buttons, reward, term, wall, label_reward,
+ entry_reward, rbtn_term, rbtn_wall):
+ """runs update_table for all cells"""
+
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ update_table(i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_term,
+ rbtn_wall)
+
+
+def reset_all(_height, i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward, rbtn_wall,
+ rbtn_term):
+ """functionality for reset button"""
+ reward.set(0.0)
+ term.set(0)
+ wall.set(0)
+ gridmdp[i][j] = 0.0
+ buttons[i][j].configure(style='TButton')
+ buttons[i][j].config(text=f'({_height - i - 1}, {j})')
+
+ if (i, j) in terminals:
+ terminals.remove((i, j))
+
+ label_reward.config(foreground='#000')
+ entry_reward.config(state=tk.NORMAL)
+ rbtn_term.config(state=tk.NORMAL)
+ rbtn_wall.config(state=tk.NORMAL)
+ rbtn_wall.state(['!focus', '!selected'])
+ rbtn_term.state(['!focus', '!selected'])
+
+
+def initialize_reset_all(_width, _height, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward,
+ rbtn_wall, rbtn_term):
+ """runs reset_all for all cells"""
+
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ reset_all(_height, i, j, gridmdp, terminals, buttons, reward, term, wall, label_reward, entry_reward,
+ rbtn_wall, rbtn_term)
- self.show_frame(HomePage)
- def placeholder_function(self):
- ''' placeholder function '''
+def external_reset(_width, _height, gridmdp, terminals, buttons):
+ """reset from edit menu"""
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ gridmdp[i][j] = 0.0
+ buttons[i][j].configure(style='TButton')
+ buttons[i][j].config(text=f'({_height - i - 1}, {j})')
- print('Not supported yet!')
- def exit(self):
- ''' function to exit '''
+def widget_disability_checks(i, j, gridmdp, terminals, label_reward, entry_reward, rbtn_wall, rbtn_term):
+ """checks for required state of widgets in dialog boxes"""
- if tkinter.messagebox.askokcancel('Exit?', 'All changes will be lost'):
- quit()
+ if gridmdp[i][j] == WALL_VALUE:
+ label_reward.config(foreground='#999')
+ entry_reward.config(state=tk.DISABLED)
+ rbtn_term.config(state=tk.DISABLED)
+ rbtn_wall.state(['!focus', 'selected'])
+ rbtn_term.state(['!focus', '!selected'])
- def new(self):
- ''' function to create new GridMDP '''
+ if (i, j) in terminals:
+ rbtn_wall.config(state=tk.DISABLED)
+ rbtn_wall.state(['!focus', '!selected'])
- self.master_reset()
- build_page = self.get_page(BuildMDP)
- build_page.gridmdp = None
- build_page.terminals = None
- build_page.buttons = None
- self.show_frame(HomePage)
- def get_page(self, page_class):
- ''' returns pages from stored frames '''
+def flatten_list(_list):
+ """returns a flattened list"""
+ return sum(_list, [])
- return self.frames[page_class]
- def view_matrix(self):
- ''' prints current matrix to console '''
+def initialize_widget_disability_checks(_width, _height, gridmdp, terminals, label_reward, entry_reward, rbtn_wall,
+ rbtn_term):
+ """checks for required state of widgets when cells are initialized"""
- build_page = self.get_page(BuildMDP)
- _height = self.shared_data['height'].get()
- _width = self.shared_data['width'].get()
- print(build_page.gridmdp)
- display(build_page.gridmdp, _height, _width)
+ bool_walls = [['False'] * max(1, _width) for _ in range(max(1, _height))]
+ bool_terms = [['False'] * max(1, _width) for _ in range(max(1, _height))]
- def view_terminals(self):
- ''' prints current terminals to console '''
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ if gridmdp[i][j] == WALL_VALUE:
+ bool_walls[i][j] = 'True'
- build_page = self.get_page(BuildMDP)
- print('Terminals', build_page.terminals)
+ if (i, j) in terminals:
+ bool_terms[i][j] = 'True'
- def initialize(self):
- ''' calls initialize from BuildMDP '''
+ bool_walls_fl = flatten_list(bool_walls)
+ bool_terms_fl = flatten_list(bool_terms)
- build_page = self.get_page(BuildMDP)
- build_page.initialize()
+ if bool_walls_fl.count('True') == len(bool_walls_fl):
+ print('`')
+ label_reward.config(foreground='#999')
+ entry_reward.config(state=tk.DISABLED)
+ rbtn_term.config(state=tk.DISABLED)
+ rbtn_wall.state(['!focus', 'selected'])
+ rbtn_term.state(['!focus', '!selected'])
- def master_reset(self):
- ''' calls master_reset from BuildMDP '''
+ if bool_terms_fl.count('True') == len(bool_terms_fl):
+ rbtn_wall.config(state=tk.DISABLED)
+ rbtn_wall.state(['!focus', '!selected'])
+ rbtn_term.state(['!focus', 'selected'])
- build_page = self.get_page(BuildMDP)
- build_page.master_reset()
- def build(self):
- ''' runs specified mdp solving algorithm '''
+def dialogbox(i, j, gridmdp, terminals, buttons, _height):
+ """creates dialogbox for each cell"""
+ global cell_window_mantainer
+ if (cell_window_mantainer != None):
+ cell_window_mantainer.destroy()
+
+ dialog = tk.Toplevel()
+ cell_window_mantainer = dialog
+ dialog.wm_title(f'{_height - i - 1}, {j}')
+
+ container = tk.Frame(dialog)
+ container.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+ container.grid_rowconfigure(0, weight=1)
+ container.grid_columnconfigure(0, weight=1)
+
+ wall = tk.IntVar()
+ wall.set(gridmdp[i][j])
+ term = tk.IntVar()
+ term.set(TERM_VALUE if (i, j) in terminals else 0.0)
+ reward = tk.DoubleVar()
+ reward.set(gridmdp[i][j] if gridmdp[i][j] != WALL_VALUE else 0.0)
+
+ label = ttk.Label(container, text=f'Configure cell {_height - i - 1}, {j}', font=('Helvetica', 12), anchor=tk.N)
+ label.grid(row=0, column=0, columnspan=3, sticky='new', pady=15, padx=5)
+ label_reward = ttk.Label(container, text='Reward', font=('Helvetica', 10), anchor=tk.N)
+ label_reward.grid(row=1, column=0, columnspan=3, sticky='new', pady=1, padx=5)
+ entry_reward = ttk.Entry(container, font=('Helvetica', 10), justify=tk.CENTER, exportselection=0,
+ textvariable=reward)
+ entry_reward.grid(row=2, column=0, columnspan=3, sticky='new', pady=5, padx=50)
+
+ rbtn_term = ttk.Radiobutton(container, text='Terminal', variable=term, value=TERM_VALUE)
+ rbtn_term.grid(row=3, column=0, columnspan=3, sticky='nsew', padx=160, pady=5)
+ rbtn_wall = ttk.Radiobutton(container, text='Wall', variable=wall, value=WALL_VALUE)
+ rbtn_wall.grid(row=4, column=0, columnspan=3, sticky='nsew', padx=172, pady=5)
+
+ widget_disability_checks(i, j, gridmdp, terminals, label_reward, entry_reward, rbtn_wall, rbtn_term)
+
+ btn_apply = ttk.Button(container, text='Apply',
+ command=partial(update_table, i, j, gridmdp, terminals, buttons, reward, term, wall,
+ label_reward, entry_reward, rbtn_term, rbtn_wall))
+ btn_apply.grid(row=5, column=0, sticky='nsew', pady=5, padx=5)
+ btn_reset = ttk.Button(container, text='Reset',
+ command=partial(reset_all, _height, i, j, gridmdp, terminals, buttons, reward, term, wall,
+ label_reward, entry_reward, rbtn_wall, rbtn_term))
+ btn_reset.grid(row=5, column=1, sticky='nsew', pady=5, padx=5)
+ btn_ok = ttk.Button(container, text='Ok', command=dialog.destroy)
+ btn_ok.grid(row=5, column=2, sticky='nsew', pady=5, padx=5)
+
+ dialog.geometry('400x200')
+ dialog.mainloop()
- frame = SolveMDP(self.container, self)
- self.frames[SolveMDP] = frame
- frame.grid(row=0, column=0, sticky='nsew')
- self.show_frame(SolveMDP)
- build_page = self.get_page(BuildMDP)
- gridmdp = build_page.gridmdp
- terminals = build_page.terminals
- solve_page = self.get_page(SolveMDP)
- _height = self.shared_data['height'].get()
- _width = self.shared_data['width'].get()
- solve_page.create_graph(gridmdp, terminals, _height, _width)
- def show_frame(self, controller, cb=False):
- ''' shows specified frame and optionally runs create_buttons '''
+class MDPapp(tk.Tk):
- if cb:
- build_page = self.get_page(BuildMDP)
- build_page.create_buttons()
- frame = self.frames[controller]
- frame.tkraise()
+ def __init__(self, *args, **kwargs):
+
+ tk.Tk.__init__(self, *args, **kwargs)
+ tk.Tk.wm_title(self, 'Grid MDP')
+ self.shared_data = {
+ 'height': tk.IntVar(),
+ 'width': tk.IntVar()}
+ self.shared_data['height'].set(1)
+ self.shared_data['width'].set(1)
+ self.container = tk.Frame(self)
+ self.container.pack(side='top', fill='both', expand=True)
+ self.container.grid_rowconfigure(0, weight=1)
+ self.container.grid_columnconfigure(0, weight=1)
+
+ self.frames = {}
+
+ self.menu_bar = tk.Menu(self.container)
+ self.file_menu = tk.Menu(self.menu_bar, tearoff=0)
+ self.file_menu.add_command(label='Exit', command=self.exit)
+ self.menu_bar.add_cascade(label='File', menu=self.file_menu)
+
+ self.edit_menu = tk.Menu(self.menu_bar, tearoff=1)
+ self.edit_menu.add_command(label='Reset', command=self.master_reset)
+ self.edit_menu.add_command(label='Initialize', command=self.initialize)
+ self.edit_menu.add_separator()
+ self.edit_menu.add_command(label='View matrix', command=self.view_matrix)
+ self.edit_menu.add_command(label='View terminals', command=self.view_terminals)
+ self.menu_bar.add_cascade(label='Edit', menu=self.edit_menu)
+ self.menu_bar.entryconfig('Edit', state=tk.DISABLED)
+
+ self.build_menu = tk.Menu(self.menu_bar, tearoff=1)
+ self.build_menu.add_command(label='Build and Run', command=self.build)
+ self.menu_bar.add_cascade(label='Build', menu=self.build_menu)
+ self.menu_bar.entryconfig('Build', state=tk.DISABLED)
+ tk.Tk.config(self, menu=self.menu_bar)
+
+ for F in (HomePage, BuildMDP, SolveMDP):
+ frame = F(self.container, self)
+ self.frames[F] = frame
+ frame.grid(row=0, column=0, sticky='nsew')
+
+ self.show_frame(HomePage)
+
+ def placeholder_function(self):
+ """placeholder function"""
+
+ print('Not supported yet!')
+
+ def exit(self):
+ """function to exit"""
+ if tkinter.messagebox.askokcancel('Exit?', 'All changes will be lost'):
+ quit()
+
+ def new(self):
+ """function to create new GridMDP"""
+
+ self.master_reset()
+ build_page = self.get_page(BuildMDP)
+ build_page.gridmdp = None
+ build_page.terminals = None
+ build_page.buttons = None
+ self.show_frame(HomePage)
+
+ def get_page(self, page_class):
+ """returns pages from stored frames"""
+ return self.frames[page_class]
+
+ def view_matrix(self):
+ """prints current matrix to console"""
+
+ build_page = self.get_page(BuildMDP)
+ _height = self.shared_data['height'].get()
+ _width = self.shared_data['width'].get()
+ print(build_page.gridmdp)
+ display(build_page.gridmdp, _height, _width)
+
+ def view_terminals(self):
+ """prints current terminals to console"""
+ build_page = self.get_page(BuildMDP)
+ print('Terminals', build_page.terminals)
+
+ def initialize(self):
+ """calls initialize from BuildMDP"""
+
+ build_page = self.get_page(BuildMDP)
+ build_page.initialize()
+
+ def master_reset(self):
+ """calls master_reset from BuildMDP"""
+ build_page = self.get_page(BuildMDP)
+ build_page.master_reset()
+
+ def build(self):
+ """runs specified mdp solving algorithm"""
+
+ frame = SolveMDP(self.container, self)
+ self.frames[SolveMDP] = frame
+ frame.grid(row=0, column=0, sticky='nsew')
+ self.show_frame(SolveMDP)
+ build_page = self.get_page(BuildMDP)
+ gridmdp = build_page.gridmdp
+ terminals = build_page.terminals
+ solve_page = self.get_page(SolveMDP)
+ _height = self.shared_data['height'].get()
+ _width = self.shared_data['width'].get()
+ solve_page.create_graph(gridmdp, terminals, _height, _width)
+
+ def show_frame(self, controller, cb=False):
+ """shows specified frame and optionally runs create_buttons"""
+ if cb:
+ build_page = self.get_page(BuildMDP)
+ build_page.create_buttons()
+ frame = self.frames[controller]
+ frame.tkraise()
class HomePage(tk.Frame):
- def __init__(self, parent, controller):
- ''' HomePage constructor '''
-
- tk.Frame.__init__(self, parent)
- self.controller = controller
- frame1 = tk.Frame(self)
- frame1.pack(side=tk.TOP)
- frame3 = tk.Frame(self)
- frame3.pack(side=tk.TOP)
- frame4 = tk.Frame(self)
- frame4.pack(side=tk.TOP)
- frame2 = tk.Frame(self)
- frame2.pack(side=tk.TOP)
-
- s = ttk.Style()
- s.theme_use('clam')
- s.configure('TButton', background=grayd, padding=0)
- s.configure('wall.TButton', background=gray2, foreground=white)
- s.configure('reward.TButton', background=gray9)
- s.configure('+term.TButton', background=green8)
- s.configure('-term.TButton', background=pblue, foreground=white)
- s.configure('=term.TButton', background=green4)
-
- label = ttk.Label(frame1, text='GridMDP builder', font=('Helvetica', 18, 'bold'), background=grayef)
- label.pack(pady=75, padx=50, side=tk.TOP)
-
- ec_btn = ttk.Button(frame3, text='Empty cells', width=20)
- ec_btn.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
- ec_btn.configure(style='TButton')
-
- w_btn = ttk.Button(frame3, text='Walls', width=20)
- w_btn.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
- w_btn.configure(style='wall.TButton')
-
- r_btn = ttk.Button(frame3, text='Rewards', width=20)
- r_btn.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
- r_btn.configure(style='reward.TButton')
-
- term_p = ttk.Button(frame3, text='Positive terminals', width=20)
- term_p.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
- term_p.configure(style='+term.TButton')
-
- term_z = ttk.Button(frame3, text='Neutral terminals', width=20)
- term_z.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
- term_z.configure(style='=term.TButton')
-
- term_n = ttk.Button(frame3, text='Negative terminals', width=20)
- term_n.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
- term_n.configure(style='-term.TButton')
-
- label = ttk.Label(frame4, text='Dimensions', font=('Verdana', 14), background=grayef)
- label.pack(pady=15, padx=10, side=tk.TOP)
- entry_h = tk.Entry(frame2, textvariable=self.controller.shared_data['height'], font=('Verdana', 10), width=3, justify=tk.CENTER)
- entry_h.pack(pady=10, padx=10, side=tk.LEFT)
- label_x = ttk.Label(frame2, text='X', font=('Verdana', 10), background=grayef)
- label_x.pack(pady=10, padx=4, side=tk.LEFT)
- entry_w = tk.Entry(frame2, textvariable=self.controller.shared_data['width'], font=('Verdana', 10), width=3, justify=tk.CENTER)
- entry_w.pack(pady=10, padx=10, side=tk.LEFT)
- button = ttk.Button(self, text='Build a GridMDP', command=lambda: controller.show_frame(BuildMDP, cb=True))
- button.pack(pady=10, padx=10, side=tk.TOP, ipadx=20, ipady=10)
- button.configure(style='reward.TButton')
+ def __init__(self, parent, controller):
+ """HomePage constructor"""
+
+ tk.Frame.__init__(self, parent)
+ self.controller = controller
+ frame1 = tk.Frame(self)
+ frame1.pack(side=tk.TOP)
+ frame3 = tk.Frame(self)
+ frame3.pack(side=tk.TOP)
+ frame4 = tk.Frame(self)
+ frame4.pack(side=tk.TOP)
+ frame2 = tk.Frame(self)
+ frame2.pack(side=tk.TOP)
+
+ s = ttk.Style()
+ s.theme_use('clam')
+ s.configure('TButton', background=grayd, padding=0)
+ s.configure('wall.TButton', background=gray2, foreground=white)
+ s.configure('reward.TButton', background=gray9)
+ s.configure('+term.TButton', background=green8)
+ s.configure('-term.TButton', background=pblue, foreground=white)
+ s.configure('=term.TButton', background=green4)
+
+ label = ttk.Label(frame1, text='GridMDP builder', font=('Helvetica', 18, 'bold'), background=grayef)
+ label.pack(pady=75, padx=50, side=tk.TOP)
+
+ ec_btn = ttk.Button(frame3, text='Empty cells', width=20)
+ ec_btn.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
+ ec_btn.configure(style='TButton')
+
+ w_btn = ttk.Button(frame3, text='Walls', width=20)
+ w_btn.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
+ w_btn.configure(style='wall.TButton')
+
+ r_btn = ttk.Button(frame3, text='Rewards', width=20)
+ r_btn.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
+ r_btn.configure(style='reward.TButton')
+
+ term_p = ttk.Button(frame3, text='Positive terminals', width=20)
+ term_p.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
+ term_p.configure(style='+term.TButton')
+
+ term_z = ttk.Button(frame3, text='Neutral terminals', width=20)
+ term_z.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
+ term_z.configure(style='=term.TButton')
+
+ term_n = ttk.Button(frame3, text='Negative terminals', width=20)
+ term_n.pack(pady=0, padx=0, side=tk.LEFT, ipady=10)
+ term_n.configure(style='-term.TButton')
+
+ label = ttk.Label(frame4, text='Dimensions', font=('Verdana', 14), background=grayef)
+ label.pack(pady=15, padx=10, side=tk.TOP)
+ entry_h = tk.Entry(frame2, textvariable=self.controller.shared_data['height'], font=('Verdana', 10), width=3,
+ justify=tk.CENTER)
+ entry_h.pack(pady=10, padx=10, side=tk.LEFT)
+ label_x = ttk.Label(frame2, text='X', font=('Verdana', 10), background=grayef)
+ label_x.pack(pady=10, padx=4, side=tk.LEFT)
+ entry_w = tk.Entry(frame2, textvariable=self.controller.shared_data['width'], font=('Verdana', 10), width=3,
+ justify=tk.CENTER)
+ entry_w.pack(pady=10, padx=10, side=tk.LEFT)
+ button = ttk.Button(self, text='Build a GridMDP', command=lambda: controller.show_frame(BuildMDP, cb=True))
+ button.pack(pady=10, padx=10, side=tk.TOP, ipadx=20, ipady=10)
+ button.configure(style='reward.TButton')
class BuildMDP(tk.Frame):
- def __init__(self, parent, controller):
-
- tk.Frame.__init__(self, parent)
- self.grid_rowconfigure(0, weight=1)
- self.grid_columnconfigure(0, weight=1)
- self.frame = tk.Frame(self)
- self.frame.pack()
- self.controller = controller
-
- def create_buttons(self):
- ''' creates interactive cells to build MDP '''
-
- _height = self.controller.shared_data['height'].get()
- _width = self.controller.shared_data['width'].get()
- self.controller.menu_bar.entryconfig('Edit', state=tk.NORMAL)
- self.controller.menu_bar.entryconfig('Build', state=tk.NORMAL)
- self.gridmdp = [[0.0]*max(1, _width) for _ in range(max(1, _height))]
- self.buttons = [[None]*max(1, _width) for _ in range(max(1, _height))]
- self.terminals = []
-
- s = ttk.Style()
- s.theme_use('clam')
- s.configure('TButton', background=grayd, padding=0)
- s.configure('wall.TButton', background=gray2, foreground=white)
- s.configure('reward.TButton', background=gray9)
- s.configure('+term.TButton', background=green8)
- s.configure('-term.TButton', background=pblue, foreground=white)
- s.configure('=term.TButton', background=green4)
-
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- self.buttons[i][j] = ttk.Button(self.frame, text=f'({_height - i - 1}, {j})', width=int(196/max(1, _width)), command=partial(dialogbox, i, j, self.gridmdp, self.terminals, self.buttons, _height))
- self.buttons[i][j].grid(row=i, column=j, ipady=int(336/max(1, _height)) - 12)
-
- def initialize(self):
- ''' runs initialize_dialogbox '''
-
- _height = self.controller.shared_data['height'].get()
- _width = self.controller.shared_data['width'].get()
- initialize_dialogbox(_width, _height, self.gridmdp, self.terminals, self.buttons)
-
- def master_reset(self):
- ''' runs external reset '''
-
- _height = self.controller.shared_data['height'].get()
- _width = self.controller.shared_data['width'].get()
- if tkinter.messagebox.askokcancel('Reset', 'Are you sure you want to reset all cells?'):
- external_reset(_width, _height, self.gridmdp, self.terminals, self.buttons)
+ def __init__(self, parent, controller):
+
+ tk.Frame.__init__(self, parent)
+ self.grid_rowconfigure(0, weight=1)
+ self.grid_columnconfigure(0, weight=1)
+ self.frame = tk.Frame(self)
+ self.frame.pack()
+ self.controller = controller
+
+ def create_buttons(self):
+ """creates interactive cells to build MDP"""
+ _height = self.controller.shared_data['height'].get()
+ _width = self.controller.shared_data['width'].get()
+ self.controller.menu_bar.entryconfig('Edit', state=tk.NORMAL)
+ self.controller.menu_bar.entryconfig('Build', state=tk.NORMAL)
+ self.gridmdp = [[0.0] * max(1, _width) for _ in range(max(1, _height))]
+ self.buttons = [[None] * max(1, _width) for _ in range(max(1, _height))]
+ self.terminals = []
+
+ s = ttk.Style()
+ s.theme_use('clam')
+ s.configure('TButton', background=grayd, padding=0)
+ s.configure('wall.TButton', background=gray2, foreground=white)
+ s.configure('reward.TButton', background=gray9)
+ s.configure('+term.TButton', background=green8)
+ s.configure('-term.TButton', background=pblue, foreground=white)
+ s.configure('=term.TButton', background=green4)
+
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ self.buttons[i][j] = ttk.Button(self.frame, text=f'({_height - i - 1}, {j})',
+ width=int(196 / max(1, _width)),
+ command=partial(dialogbox, i, j, self.gridmdp, self.terminals,
+ self.buttons, _height))
+ self.buttons[i][j].grid(row=i, column=j, ipady=int(336 / max(1, _height)) - 12)
+
+ def initialize(self):
+ """runs initialize_dialogbox"""
+
+ _height = self.controller.shared_data['height'].get()
+ _width = self.controller.shared_data['width'].get()
+ initialize_dialogbox(_width, _height, self.gridmdp, self.terminals, self.buttons)
+
+ def master_reset(self):
+ """runs external reset"""
+ _height = self.controller.shared_data['height'].get()
+ _width = self.controller.shared_data['width'].get()
+ if tkinter.messagebox.askokcancel('Reset', 'Are you sure you want to reset all cells?'):
+ external_reset(_width, _height, self.gridmdp, self.terminals, self.buttons)
class SolveMDP(tk.Frame):
- def __init__(self, parent, controller):
+ def __init__(self, parent, controller):
- tk.Frame.__init__(self, parent)
- self.grid_rowconfigure(0, weight=1)
- self.grid_columnconfigure(0, weight=1)
- self.frame = tk.Frame(self)
- self.frame.pack()
- self.controller = controller
- self.terminated = False
- self.iterations = 0
- self.epsilon = 0.001
- self.delta = 0
+ tk.Frame.__init__(self, parent)
+ self.grid_rowconfigure(0, weight=1)
+ self.grid_columnconfigure(0, weight=1)
+ self.frame = tk.Frame(self)
+ self.frame.pack()
+ self.controller = controller
+ self.terminated = False
+ self.iterations = 0
+ self.epsilon = 0.001
+ self.delta = 0
- def process_data(self, terminals, _height, _width, gridmdp):
- ''' preprocess variables '''
+ def process_data(self, terminals, _height, _width, gridmdp):
+ """preprocess variables"""
- flipped_terminals = []
+ flipped_terminals = []
- for terminal in terminals:
- flipped_terminals.append((terminal[1], _height - terminal[0] - 1))
+ for terminal in terminals:
+ flipped_terminals.append((terminal[1], _height - terminal[0] - 1))
- grid_to_solve = [[0.0]*max(1, _width) for _ in range(max(1, _height))]
- grid_to_show = [[0.0]*max(1, _width) for _ in range(max(1, _height))]
+ grid_to_solve = [[0.0] * max(1, _width) for _ in range(max(1, _height))]
+ grid_to_show = [[0.0] * max(1, _width) for _ in range(max(1, _height))]
- for i in range(max(1, _height)):
- for j in range(max(1, _width)):
- if gridmdp[i][j] == WALL_VALUE:
- grid_to_show[i][j] = 0.0
- grid_to_solve[i][j] = None
+ for i in range(max(1, _height)):
+ for j in range(max(1, _width)):
+ if gridmdp[i][j] == WALL_VALUE:
+ grid_to_show[i][j] = 0.0
+ grid_to_solve[i][j] = None
- else:
- grid_to_show[i][j] = grid_to_solve[i][j] = gridmdp[i][j]
+ else:
+ grid_to_show[i][j] = grid_to_solve[i][j] = gridmdp[i][j]
- return flipped_terminals, grid_to_solve, np.flipud(grid_to_show)
+ return flipped_terminals, grid_to_solve, np.flipud(grid_to_show)
- def create_graph(self, gridmdp, terminals, _height, _width):
- ''' creates canvas and initializes value_iteration_paramteres '''
+ def create_graph(self, gridmdp, terminals, _height, _width):
+ """creates canvas and initializes value_iteration_parameters"""
+ self._height = _height
+ self._width = _width
+ self.controller.menu_bar.entryconfig('Edit', state=tk.DISABLED)
+ self.controller.menu_bar.entryconfig('Build', state=tk.DISABLED)
- self._height = _height
- self._width = _width
- self.controller.menu_bar.entryconfig('Edit', state=tk.DISABLED)
- self.controller.menu_bar.entryconfig('Build', state=tk.DISABLED)
+ self.terminals, self.gridmdp, self.grid_to_show = self.process_data(terminals, _height, _width, gridmdp)
+ self.sequential_decision_environment = GridMDP(self.gridmdp, terminals=self.terminals)
- self.terminals, self.gridmdp, self.grid_to_show = self.process_data(terminals, _height, _width, gridmdp)
- self.sequential_decision_environment = GridMDP(self.gridmdp, terminals=self.terminals)
+ self.initialize_value_iteration_parameters(self.sequential_decision_environment)
- self.initialize_value_iteration_parameters(self.sequential_decision_environment)
+ self.canvas = FigureCanvasTkAgg(fig, self.frame)
+ self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+ self.anim = animation.FuncAnimation(fig, self.animate_graph, interval=50)
+ self.canvas.show()
- self.canvas = FigureCanvasTkAgg(fig, self.frame)
- self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
- self.anim = animation.FuncAnimation(fig, self.animate_graph, interval=50)
- self.canvas.show()
+ def animate_graph(self, i):
+ """performs value iteration and animates graph"""
- def animate_graph(self, i):
- ''' performs value iteration and animates graph '''
+ # cmaps to use: bone_r, Oranges, inferno, BrBG, copper
+ self.iterations += 1
+ x_interval = max(2, len(self.gridmdp[0]))
+ y_interval = max(2, len(self.gridmdp))
+ x = np.linspace(0, len(self.gridmdp[0]) - 1, x_interval)
+ y = np.linspace(0, len(self.gridmdp) - 1, y_interval)
- # cmaps to use: bone_r, Oranges, inferno, BrBG, copper
- self.iterations += 1
- x_interval = max(2, len(self.gridmdp[0]))
- y_interval = max(2, len(self.gridmdp))
- x = np.linspace(0, len(self.gridmdp[0]) - 1, x_interval)
- y = np.linspace(0, len(self.gridmdp) - 1, y_interval)
+ sub.clear()
+ sub.imshow(self.grid_to_show, cmap='BrBG', aspect='auto', interpolation='none', extent=extents(x) + extents(y),
+ origin='lower')
+ fig.tight_layout()
- sub.clear()
- sub.imshow(self.grid_to_show, cmap='BrBG', aspect='auto', interpolation='none', extent=extents(x) + extents(y), origin='lower')
- fig.tight_layout()
+ U = self.U1.copy()
- U = self.U1.copy()
+ for s in self.sequential_decision_environment.states:
+ self.U1[s] = self.R(s) + self.gamma * max(
+ [sum([p * U[s1] for (p, s1) in self.T(s, a)]) for a in self.sequential_decision_environment.actions(s)])
+ self.delta = max(self.delta, abs(self.U1[s] - U[s]))
- for s in self.sequential_decision_environment.states:
- self.U1[s] = self.R(s) + self.gamma * max([sum([p * U[s1] for (p, s1) in self.T(s, a)]) for a in self.sequential_decision_environment.actions(s)])
- self.delta = max(self.delta, abs(self.U1[s] - U[s]))
+ self.grid_to_show = grid_to_show = [[0.0] * max(1, self._width) for _ in range(max(1, self._height))]
+ for k, v in U.items():
+ self.grid_to_show[k[1]][k[0]] = v
- self.grid_to_show = grid_to_show = [[0.0]*max(1, self._width) for _ in range(max(1, self._height))]
- for k, v in U.items():
- self.grid_to_show[k[1]][k[0]] = v
+ if (self.delta < self.epsilon * (1 - self.gamma) / self.gamma) or (
+ self.iterations > 60) and self.terminated is False:
+ self.terminated = True
+ display(self.grid_to_show, self._height, self._width)
- if (self.delta < self.epsilon * (1 - self.gamma) / self.gamma) or (self.iterations > 60) and self.terminated == False:
- self.terminated = True
- display(self.grid_to_show, self._height, self._width)
-
- ax = fig.gca()
- ax.xaxis.set_major_locator(MaxNLocator(integer=True))
- ax.yaxis.set_major_locator(MaxNLocator(integer=True))
+ pi = best_policy(self.sequential_decision_environment,
+ value_iteration(self.sequential_decision_environment, .01))
+ display_best_policy(self.sequential_decision_environment.to_arrows(pi), self._height, self._width)
- def initialize_value_iteration_parameters(self, mdp):
- ''' initializes value_iteration parameters '''
+ ax = fig.gca()
+ ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+ ax.yaxis.set_major_locator(MaxNLocator(integer=True))
- self.U1 = {s: 0 for s in mdp.states}
- self.R, self.T, self.gamma = mdp.R, mdp.T, mdp.gamma
+ def initialize_value_iteration_parameters(self, mdp):
+ """initializes value_iteration parameters"""
+ self.U1 = {s: 0 for s in mdp.states}
+ self.R, self.T, self.gamma = mdp.R, mdp.T, mdp.gamma
- def value_iteration_metastep(self, mdp, iterations=20):
- ''' runs value_iteration '''
+ def value_iteration_metastep(self, mdp, iterations=20):
+ """runs value_iteration"""
- U_over_time = []
- U1 = {s: 0 for s in mdp.states}
- R, T, gamma = mdp.R, mdp.T, mdp.gamma
+ U_over_time = []
+ U1 = {s: 0 for s in mdp.states}
+ R, T, gamma = mdp.R, mdp.T, mdp.gamma
- for _ in range(iterations):
- U = U1.copy()
+ for _ in range(iterations):
+ U = U1.copy()
- for s in mdp.states:
- U1[s] = R(s) + gamma * max([sum([p * U[s1] for (p, s1) in T(s, a)]) for a in mdp.actions(s)])
+ for s in mdp.states:
+ U1[s] = R(s) + gamma * max([sum([p * U[s1] for (p, s1) in T(s, a)]) for a in mdp.actions(s)])
- U_over_time.append(U)
- return U_over_time
+ U_over_time.append(U)
+ return U_over_time
if __name__ == '__main__':
- app = MDPapp()
- app.geometry('1280x720')
- app.mainloop()
\ No newline at end of file
+ app = MDPapp()
+ app.geometry('1280x720')
+ app.mainloop()
diff --git a/gui/romania_problem.py b/gui/romania_problem.py
index 67eced970..9ec94099d 100644
--- a/gui/romania_problem.py
+++ b/gui/romania_problem.py
@@ -1,14 +1,10 @@
+from copy import deepcopy
from tkinter import *
-import sys
-import os.path
-import math
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
from search import *
-from search import breadth_first_tree_search as bfts, depth_first_tree_search as dfts, \
- depth_first_graph_search as dfgs, breadth_first_search as bfs, uniform_cost_search as ucs, \
- astar_search as asts
-from utils import Stack, FIFOQueue, PriorityQueue
-from copy import deepcopy
+from utils import PriorityQueue
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
root = None
city_coord = {}
@@ -26,9 +22,7 @@
def create_map(root):
- '''
- This function draws out the required map.
- '''
+ """This function draws out the required map."""
global city_map, start, goal
romania_locations = romania_map.locations
width = 750
@@ -260,17 +254,13 @@ def create_map(root):
def make_line(map, x0, y0, x1, y1, distance):
- '''
- This function draws out the lines joining various points.
- '''
+ """This function draws out the lines joining various points."""
map.create_line(x0, y0, x1, y1)
map.create_text((x0 + x1) / 2, (y0 + y1) / 2, text=distance)
def make_rectangle(map, x0, y0, margin, city_name):
- '''
- This function draws out rectangles for various points.
- '''
+ """This function draws out rectangles for various points."""
global city_coord
rect = map.create_rectangle(
x0 - margin,
@@ -295,7 +285,6 @@ def make_rectangle(map, x0, y0, margin, city_name):
def make_legend(map):
-
rect1 = map.create_rectangle(600, 100, 610, 110, fill="white")
text1 = map.create_text(615, 105, anchor=W, text="Un-explored")
@@ -313,51 +302,49 @@ def make_legend(map):
def tree_search(problem):
- '''
+ """
Search through the successors of a problem to find a goal.
The argument frontier should be an empty queue.
Don't worry about repeated paths to a state. [Figure 3.7]
This function has been changed to make it suitable for the Tkinter GUI.
- '''
+ """
global counter, frontier, node
- # print(counter)
+
if counter == -1:
frontier.append(Node(problem.initial))
- # print(frontier)
+
display_frontier(frontier)
if counter % 3 == 0 and counter >= 0:
node = frontier.pop()
- # print(node)
+
display_current(node)
if counter % 3 == 1 and counter >= 0:
if problem.goal_test(node.state):
- # print(node)
return node
frontier.extend(node.expand(problem))
- # print(frontier)
+
display_frontier(frontier)
if counter % 3 == 2 and counter >= 0:
- # print(node)
display_explored(node)
return None
def graph_search(problem):
- '''
+ """
Search through the successors of a problem to find a goal.
The argument frontier should be an empty queue.
If two paths reach a state, only use the first one. [Figure 3.7]
This function has been changed to make it suitable for the Tkinter GUI.
- '''
+ """
global counter, frontier, node, explored
if counter == -1:
frontier.append(Node(problem.initial))
explored = set()
- # print("Frontier: "+str(frontier))
+
display_frontier(frontier)
if counter % 3 == 0 and counter >= 0:
node = frontier.pop()
- # print("Current node: "+str(node))
+
display_current(node)
if counter % 3 == 1 and counter >= 0:
if problem.goal_test(node.state):
@@ -366,18 +353,15 @@ def graph_search(problem):
frontier.extend(child for child in node.expand(problem)
if child.state not in explored and
child not in frontier)
- # print("Frontier: " + str(frontier))
+
display_frontier(frontier)
if counter % 3 == 2 and counter >= 0:
- # print("Explored node: "+str(node))
display_explored(node)
return None
def display_frontier(queue):
- '''
- This function marks the frontier nodes (orange) on the map.
- '''
+ """This function marks the frontier nodes (orange) on the map."""
global city_map, city_coord
qu = deepcopy(queue)
while qu:
@@ -388,27 +372,21 @@ def display_frontier(queue):
def display_current(node):
- '''
- This function marks the currently exploring node (red) on the map.
- '''
+ """This function marks the currently exploring node (red) on the map."""
global city_map, city_coord
city = node.state
city_map.itemconfig(city_coord[city], fill="red")
def display_explored(node):
- '''
- This function marks the already explored node (gray) on the map.
- '''
+ """This function marks the already explored node (gray) on the map."""
global city_map, city_coord
city = node.state
city_map.itemconfig(city_coord[city], fill="gray")
def display_final(cities):
- '''
- This function marks the final solution nodes (green) on the map.
- '''
+ """This function marks the final solution nodes (green) on the map."""
global city_map, city_coord
for city in cities:
city_map.itemconfig(city_coord[city], fill="green")
@@ -416,22 +394,56 @@ def display_final(cities):
def breadth_first_tree_search(problem):
"""Search the shallowest nodes in the search tree first."""
- global frontier, counter
+ global frontier, counter, node
+ if counter == -1:
+ frontier = deque()
+
if counter == -1:
- frontier = FIFOQueue()
- return tree_search(problem)
+ frontier.append(Node(problem.initial))
+
+ display_frontier(frontier)
+ if counter % 3 == 0 and counter >= 0:
+ node = frontier.popleft()
+
+ display_current(node)
+ if counter % 3 == 1 and counter >= 0:
+ if problem.goal_test(node.state):
+ return node
+ frontier.extend(node.expand(problem))
+
+ display_frontier(frontier)
+ if counter % 3 == 2 and counter >= 0:
+ display_explored(node)
+ return None
def depth_first_tree_search(problem):
"""Search the deepest nodes in the search tree first."""
# This search algorithm might not work in case of repeated paths.
- global frontier, counter
+ global frontier, counter, node
if counter == -1:
- frontier = Stack()
- return tree_search(problem)
+ frontier = [] # stack
+
+ if counter == -1:
+ frontier.append(Node(problem.initial))
+
+ display_frontier(frontier)
+ if counter % 3 == 0 and counter >= 0:
+ node = frontier.pop()
+
+ display_current(node)
+ if counter % 3 == 1 and counter >= 0:
+ if problem.goal_test(node.state):
+ return node
+ frontier.extend(node.expand(problem))
+
+ display_frontier(frontier)
+ if counter % 3 == 2 and counter >= 0:
+ display_explored(node)
+ return None
-def breadth_first_search(problem):
+def breadth_first_graph_search(problem):
"""[Figure 3.11]"""
global frontier, node, explored, counter
if counter == -1:
@@ -439,12 +451,13 @@ def breadth_first_search(problem):
display_current(node)
if problem.goal_test(node.state):
return node
- frontier = FIFOQueue()
- frontier.append(node)
+
+ frontier = deque([node]) # FIFO queue
+
display_frontier(frontier)
explored = set()
if counter % 3 == 0 and counter >= 0:
- node = frontier.pop()
+ node = frontier.popleft()
display_current(node)
explored.add(node.state)
if counter % 3 == 1 and counter >= 0:
@@ -461,10 +474,30 @@ def breadth_first_search(problem):
def depth_first_graph_search(problem):
"""Search the deepest nodes in the search tree first."""
- global frontier, counter
+ global counter, frontier, node, explored
+ if counter == -1:
+ frontier = [] # stack
if counter == -1:
- frontier = Stack()
- return graph_search(problem)
+ frontier.append(Node(problem.initial))
+ explored = set()
+
+ display_frontier(frontier)
+ if counter % 3 == 0 and counter >= 0:
+ node = frontier.pop()
+
+ display_current(node)
+ if counter % 3 == 1 and counter >= 0:
+ if problem.goal_test(node.state):
+ return node
+ explored.add(node.state)
+ frontier.extend(child for child in node.expand(problem)
+ if child.state not in explored and
+ child not in frontier)
+
+ display_frontier(frontier)
+ if counter % 3 == 2 and counter >= 0:
+ display_explored(node)
+ return None
def best_first_graph_search(problem, f):
@@ -483,7 +516,7 @@ def best_first_graph_search(problem, f):
display_current(node)
if problem.goal_test(node.state):
return node
- frontier = PriorityQueue(min, f)
+ frontier = PriorityQueue('min', f)
frontier.append(node)
display_frontier(frontier)
explored = set()
@@ -498,9 +531,8 @@ def best_first_graph_search(problem, f):
if child.state not in explored and child not in frontier:
frontier.append(child)
elif child in frontier:
- incumbent = frontier[child]
- if f(child) < f(incumbent):
- del frontier[incumbent]
+ if f(child) < frontier[child]:
+ del frontier[child]
frontier.append(child)
display_frontier(frontier)
if counter % 3 == 2 and counter >= 0:
@@ -523,17 +555,17 @@ def astar_search(problem, h=None):
# TODO:
# Remove redundant code.
-# Make the interchangbility work between various algorithms at each step.
+# Make the interchangeability work between various algorithms at each step.
def on_click():
- '''
+ """
This function defines the action of the 'Next' button.
- '''
+ """
global algo, counter, next_button, romania_problem, start, goal
romania_problem = GraphProblem(start.get(), goal.get(), romania_map)
if "Breadth-First Tree Search" == algo.get():
node = breadth_first_tree_search(romania_problem)
if node is not None:
- final_path = bfts(romania_problem).solution()
+ final_path = breadth_first_tree_search(romania_problem).solution()
final_path.append(start.get())
display_final(final_path)
next_button.config(state="disabled")
@@ -541,15 +573,15 @@ def on_click():
elif "Depth-First Tree Search" == algo.get():
node = depth_first_tree_search(romania_problem)
if node is not None:
- final_path = dfts(romania_problem).solution()
+ final_path = depth_first_tree_search(romania_problem).solution()
final_path.append(start.get())
display_final(final_path)
next_button.config(state="disabled")
counter += 1
- elif "Breadth-First Search" == algo.get():
- node = breadth_first_search(romania_problem)
+ elif "Breadth-First Graph Search" == algo.get():
+ node = breadth_first_graph_search(romania_problem)
if node is not None:
- final_path = bfs(romania_problem).solution()
+ final_path = breadth_first_graph_search(romania_problem).solution()
final_path.append(start.get())
display_final(final_path)
next_button.config(state="disabled")
@@ -557,7 +589,7 @@ def on_click():
elif "Depth-First Graph Search" == algo.get():
node = depth_first_graph_search(romania_problem)
if node is not None:
- final_path = dfgs(romania_problem).solution()
+ final_path = depth_first_graph_search(romania_problem).solution()
final_path.append(start.get())
display_final(final_path)
next_button.config(state="disabled")
@@ -565,7 +597,7 @@ def on_click():
elif "Uniform Cost Search" == algo.get():
node = uniform_cost_search(romania_problem)
if node is not None:
- final_path = ucs(romania_problem).solution()
+ final_path = uniform_cost_search(romania_problem).solution()
final_path.append(start.get())
display_final(final_path)
next_button.config(state="disabled")
@@ -573,7 +605,7 @@ def on_click():
elif "A* - Search" == algo.get():
node = astar_search(romania_problem)
if node is not None:
- final_path = asts(romania_problem).solution()
+ final_path = astar_search(romania_problem).solution()
final_path.append(start.get())
display_final(final_path)
next_button.config(state="disabled")
@@ -587,10 +619,9 @@ def reset_map():
city_map.itemconfig(city_coord[city], fill="white")
next_button.config(state="normal")
-# TODO: Add more search algorithms in the OptionMenu
-
-def main():
+# TODO: Add more search algorithms in the OptionMenu
+if __name__ == "__main__":
global algo, start, goal, next_button
root = Tk()
root.title("Road Map of Romania")
@@ -605,7 +636,7 @@ def main():
algorithm_menu = OptionMenu(
root,
algo, "Breadth-First Tree Search", "Depth-First Tree Search",
- "Breadth-First Search", "Depth-First Graph Search",
+ "Breadth-First Graph Search", "Depth-First Graph Search",
"Uniform Cost Search", "A* - Search")
Label(root, text="\n Search Algorithm").pack()
algorithm_menu.pack()
@@ -639,7 +670,3 @@ def main():
frame1.pack(side=BOTTOM)
create_map(root)
root.mainloop()
-
-
-if __name__ == "__main__":
- main()
diff --git a/gui/tic-tac-toe.py b/gui/tic-tac-toe.py
index 5c3bdb497..66d9d6e75 100644
--- a/gui/tic-tac-toe.py
+++ b/gui/tic-tac-toe.py
@@ -1,11 +1,12 @@
-from tkinter import *
-import sys
import os.path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from games import minimax_decision, alphabeta_player, random_player, TicTacToe
+from tkinter import *
+
+from games import minmax_decision, alpha_beta_player, random_player, TicTacToe
# "gen_state" can be used to generate a game state to apply the algorithm
from tests.test_games import gen_state
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
ttt = TicTacToe()
root = None
buttons = []
@@ -95,9 +96,9 @@ def on_click(button):
if "Random" in choice:
a, b = random_player(ttt, state)
elif "Pro" in choice:
- a, b = minimax_decision(state, ttt)
+ a, b = minmax_decision(state, ttt)
else:
- a, b = alphabeta_player(ttt, state)
+ a, b = alpha_beta_player(ttt, state)
except (ValueError, IndexError, TypeError) as e:
disable_game()
result.set("It's a draw :|")
@@ -152,8 +153,7 @@ def check_victory(button):
return True
# check if previous move was on the secondary diagonal and caused a win
- if x + y \
- == 2 and buttons[0][2]['text'] == buttons[1][1]['text'] == buttons[2][0]['text'] != " ":
+ if x + y == 2 and buttons[0][2]['text'] == buttons[1][1]['text'] == buttons[2][0]['text'] != " ":
buttons[0][2].config(text="/" + tt + "/")
buttons[1][1].config(text="/" + tt + "/")
buttons[2][0].config(text="/" + tt + "/")
@@ -213,7 +213,7 @@ def exit_game(root):
root.destroy()
-def main():
+if __name__ == "__main__":
global result, choices
root = Tk()
@@ -230,7 +230,3 @@ def main():
menu = OptionMenu(root, choices, "Vs Random", "Vs Pro", "Vs Legend")
menu.pack()
root.mainloop()
-
-
-if __name__ == "__main__":
- main()
diff --git a/gui/tsp.py b/gui/tsp.py
index 1830cba23..590fff354 100644
--- a/gui/tsp.py
+++ b/gui/tsp.py
@@ -1,21 +1,19 @@
from tkinter import *
from tkinter import messagebox
-import sys
-import os.path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from search import *
+
import utils
-import numpy as np
+from search import *
-distances = {}
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+distances = {}
-class TSP_problem(Problem):
- """ subclass of Problem to define various functions """
+class TSProblem(Problem):
+ """subclass of Problem to define various functions"""
def two_opt(self, state):
- """ Neighbour generating function for Traveling Salesman Problem """
+ """Neighbour generating function for Traveling Salesman Problem"""
neighbour_state = state[:]
left = random.randint(0, len(neighbour_state) - 1)
right = random.randint(0, len(neighbour_state) - 1)
@@ -25,15 +23,15 @@ def two_opt(self, state):
return neighbour_state
def actions(self, state):
- """ action that can be excuted in given state """
+ """action that can be executed in given state"""
return [self.two_opt]
def result(self, state, action):
- """ result after applying the given action on the given state """
+ """result after applying the given action on the given state"""
return action(state)
def path_cost(self, c, state1, action, state2):
- """ total distance for the Traveling Salesman to be covered if in state2 """
+ """total distance for the Traveling Salesman to be covered if in state2"""
cost = 0
for i in range(len(state2) - 1):
cost += distances[state2[i]][state2[i + 1]]
@@ -41,12 +39,12 @@ def path_cost(self, c, state1, action, state2):
return cost
def value(self, state):
- """ value of path cost given negative for the given state """
+ """value of path cost given negative for the given state"""
return -1 * self.path_cost(None, None, None, state)
-class TSP_Gui():
- """ Class to create gui of Traveling Salesman using simulated annealing where one can
+class TSPGui():
+ """Class to create gui of Traveling Salesman using simulated annealing where one can
select cities, change speed and temperature. Distances between cities are euclidean
distances between them.
"""
@@ -67,7 +65,7 @@ def __init__(self, root, all_cities):
Label(self.root, text="Map of Romania", font="Times 13 bold").grid(row=0, columnspan=10)
def create_checkboxes(self, side=LEFT, anchor=W):
- """ To select cities which are to be a part of Traveling Salesman Problem """
+ """To select cities which are to be a part of Traveling Salesman Problem"""
row_number = 0
column_number = 0
@@ -85,7 +83,7 @@ def create_checkboxes(self, side=LEFT, anchor=W):
row_number += 1
def create_buttons(self):
- """ Create start and quit button """
+ """Create start and quit button"""
Button(self.frame_select_cities, textvariable=self.button_text,
command=self.run_traveling_salesman).grid(row=5, column=4, sticky=E + W)
@@ -93,7 +91,7 @@ def create_buttons(self):
row=5, column=5, sticky=E + W)
def create_dropdown_menu(self):
- """ Create dropdown menu for algorithm selection """
+ """Create dropdown menu for algorithm selection"""
choices = {'Simulated Annealing', 'Genetic Algorithm', 'Hill Climbing'}
self.algo_var.set('Simulated Annealing')
@@ -102,19 +100,19 @@ def create_dropdown_menu(self):
dropdown_menu.config(width=19)
def run_traveling_salesman(self):
- """ Choose selected citites """
+ """Choose selected cities"""
cities = []
for i in range(len(self.vars)):
if self.vars[i].get() == 1:
cities.append(self.all_cities[i])
- tsp_problem = TSP_problem(cities)
+ tsp_problem = TSProblem(cities)
self.button_text.set("Reset")
self.create_canvas(tsp_problem)
def calculate_canvas_size(self):
- """ Width and height for canvas """
+ """Width and height for canvas"""
minx, maxx = sys.maxsize, -1 * sys.maxsize
miny, maxy = sys.maxsize, -1 * sys.maxsize
@@ -137,7 +135,7 @@ def calculate_canvas_size(self):
self.canvas_height = canvas_height
def create_canvas(self, problem):
- """ creating map with cities """
+ """creating map with cities"""
map_canvas = Canvas(self.frame_canvas, width=self.canvas_width, height=self.canvas_height)
map_canvas.grid(row=3, columnspan=10)
@@ -163,18 +161,18 @@ def create_canvas(self, problem):
variable=self.speed, label="Speed ----> ", showvalue=0, font="Times 11",
relief="sunken", cursor="gumby")
speed_scale.grid(row=1, columnspan=5, sticky=N + S + E + W)
-
+
if self.algo_var.get() == 'Simulated Annealing':
self.temperature = IntVar()
temperature_scale = Scale(self.frame_canvas, from_=100, to=0, orient=HORIZONTAL,
- length=200, variable=self.temperature, label="Temperature ---->",
- font="Times 11", relief="sunken", showvalue=0, cursor="gumby")
+ length=200, variable=self.temperature, label="Temperature ---->",
+ font="Times 11", relief="sunken", showvalue=0, cursor="gumby")
temperature_scale.grid(row=1, column=5, columnspan=5, sticky=N + S + E + W)
self.simulated_annealing_with_tunable_T(problem, map_canvas)
elif self.algo_var.get() == 'Genetic Algorithm':
self.mutation_rate = DoubleVar()
self.mutation_rate.set(0.05)
- mutation_rate_scale = Scale(self.frame_canvas, from_=0, to=1, orient=HORIZONTAL,
+ mutation_rate_scale = Scale(self.frame_canvas, from_=0, to=1, orient=HORIZONTAL,
length=200, variable=self.mutation_rate, label='Mutation Rate ---->',
font='Times 11', relief='sunken', showvalue=0, cursor='gumby', resolution=0.001)
mutation_rate_scale.grid(row=1, column=5, columnspan=5, sticky='nsew')
@@ -182,23 +180,23 @@ def create_canvas(self, problem):
elif self.algo_var.get() == 'Hill Climbing':
self.no_of_neighbors = IntVar()
self.no_of_neighbors.set(100)
- no_of_neighbors_scale = Scale(self.frame_canvas, from_=10, to=1000, orient=HORIZONTAL,
+ no_of_neighbors_scale = Scale(self.frame_canvas, from_=10, to=1000, orient=HORIZONTAL,
length=200, variable=self.no_of_neighbors, label='Number of neighbors ---->',
- font='Times 11',relief='sunken', showvalue=0, cursor='gumby')
+ font='Times 11', relief='sunken', showvalue=0, cursor='gumby')
no_of_neighbors_scale.grid(row=1, column=5, columnspan=5, sticky='nsew')
self.hill_climbing(problem, map_canvas)
def exp_schedule(k=100, lam=0.03, limit=1000):
- """ One possible schedule function for simulated annealing """
+ """One possible schedule function for simulated annealing"""
- return lambda t: (k * math.exp(-lam * t) if t < limit else 0)
+ return lambda t: (k * np.exp(-lam * t) if t < limit else 0)
def simulated_annealing_with_tunable_T(self, problem, map_canvas, schedule=exp_schedule()):
- """ Simulated annealing where temperature is taken as user input """
+ """Simulated annealing where temperature is taken as user input"""
current = Node(problem.initial)
- while(1):
+ while True:
T = schedule(self.temperature.get())
if T == 0:
return current.state
@@ -207,7 +205,7 @@ def simulated_annealing_with_tunable_T(self, problem, map_canvas, schedule=exp_s
return current.state
next = random.choice(neighbors)
delta_e = problem.value(next.state) - problem.value(current.state)
- if delta_e > 0 or probability(math.exp(delta_e / T)):
+ if delta_e > 0 or probability(np.exp(delta_e / T)):
map_canvas.delete("poly")
current = next
@@ -221,10 +219,10 @@ def simulated_annealing_with_tunable_T(self, problem, map_canvas, schedule=exp_s
map_canvas.after(self.speed.get())
def genetic_algorithm(self, problem, map_canvas):
- """ Genetic Algorithm modified for the given problem """
+ """Genetic Algorithm modified for the given problem"""
def init_population(pop_number, gene_pool, state_length):
- """ initialize population """
+ """initialize population"""
population = []
for i in range(pop_number):
@@ -232,7 +230,7 @@ def init_population(pop_number, gene_pool, state_length):
return population
def recombine(state_a, state_b):
- """ recombine two problem states """
+ """recombine two problem states"""
start = random.randint(0, len(state_a) - 1)
end = random.randint(start + 1, len(state_a))
@@ -243,7 +241,7 @@ def recombine(state_a, state_b):
return new_state
def mutate(state, mutation_rate):
- """ mutate problem states """
+ """mutate problem states"""
if random.uniform(0, 1) < mutation_rate:
sample = random.sample(range(len(state)), 2)
@@ -251,17 +249,18 @@ def mutate(state, mutation_rate):
return state
def fitness_fn(state):
- """ calculate fitness of a particular state """
-
+ """calculate fitness of a particular state"""
+
fitness = problem.value(state)
return int((5600 + fitness) ** 2)
current = Node(problem.initial)
population = init_population(100, current.state, len(current.state))
all_time_best = current.state
- while(1):
- population = [mutate(recombine(*select(2, population, fitness_fn)), self.mutation_rate.get()) for i in range(len(population))]
- current_best = utils.argmax(population, key=fitness_fn)
+ while True:
+ population = [mutate(recombine(*select(2, population, fitness_fn)), self.mutation_rate.get())
+ for _ in range(len(population))]
+ current_best = np.argmax(population, key=fitness_fn)
if fitness_fn(current_best) > fitness_fn(all_time_best):
all_time_best = current_best
self.cost.set("Cost = " + str('%0.3f' % (-1 * problem.value(all_time_best))))
@@ -280,10 +279,10 @@ def fitness_fn(state):
map_canvas.after(self.speed.get())
def hill_climbing(self, problem, map_canvas):
- """ hill climbing where number of neighbors is taken as user input """
+ """hill climbing where number of neighbors is taken as user input"""
def find_neighbors(state, number_of_neighbors=100):
- """ finds neighbors using two_opt method """
+ """finds neighbors using two_opt method"""
neighbors = []
for i in range(number_of_neighbors):
@@ -293,9 +292,9 @@ def find_neighbors(state, number_of_neighbors=100):
return neighbors
current = Node(problem.initial)
- while(1):
+ while True:
neighbors = find_neighbors(current.state, self.no_of_neighbors.get())
- neighbor = utils.argmax_random_tie(neighbors, key=lambda node: problem.value(node.state))
+ neighbor = np.argmax_random_tie(neighbors, key=lambda node: problem.value(node.state))
map_canvas.delete('poly')
points = []
for city in current.state:
@@ -317,7 +316,8 @@ def on_closing(self):
if messagebox.askokcancel('Quit', 'Do you want to quit?'):
self.root.destroy()
-def main():
+
+if __name__ == '__main__':
all_cities = []
for city in romania_map.locations.keys():
distances[city] = {}
@@ -334,13 +334,9 @@ def main():
root = Tk()
root.title("Traveling Salesman Problem")
- cities_selection_panel = TSP_Gui(root, all_cities)
+ cities_selection_panel = TSPGui(root, all_cities)
cities_selection_panel.create_checkboxes()
cities_selection_panel.create_buttons()
cities_selection_panel.create_dropdown_menu()
root.protocol('WM_DELETE_WINDOW', cities_selection_panel.on_closing)
root.mainloop()
-
-
-if __name__ == '__main__':
- main()
diff --git a/gui/vacuum_agent.py b/gui/vacuum_agent.py
index 23292efb3..b07dab282 100644
--- a/gui/vacuum_agent.py
+++ b/gui/vacuum_agent.py
@@ -1,15 +1,14 @@
-from tkinter import *
-import random
-import sys
import os.path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+from tkinter import *
+
from agents import *
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
loc_A, loc_B = (0, 0), (1, 0) # The two locations for the Vacuum world
class Gui(Environment):
-
"""This GUI environment has two locations, A and B. Each can be Dirty
or Clean. The agent perceives its location and the location's
status."""
@@ -33,7 +32,7 @@ def thing_classes(self):
def percept(self, agent):
"""Returns the agent's location, and the location status (Dirty/Clean)."""
- return (agent.location, self.status[agent.location])
+ return agent.location, self.status[agent.location]
def execute_action(self, agent, action):
"""Change the location status (Dirty/Clean); track performance.
@@ -137,8 +136,7 @@ def move_agent(env, agent, before_step):
# TODO: Add more agents to the environment.
# TODO: Expand the environment to XYEnvironment.
-def main():
- """The main function of the program."""
+if __name__ == "__main__":
root = Tk()
root.title("Vacuum Environment")
root.geometry("420x380")
@@ -154,7 +152,3 @@ def main():
create_agent(env, agent)
next_button.config(command=lambda: env.update_env(agent))
root.mainloop()
-
-
-if __name__ == "__main__":
- main()
diff --git a/gui/xy_vacuum_environment.py b/gui/xy_vacuum_environment.py
index 14c3abc1a..093abc6c3 100644
--- a/gui/xy_vacuum_environment.py
+++ b/gui/xy_vacuum_environment.py
@@ -1,10 +1,10 @@
-from tkinter import *
-import random
-import sys
import os.path
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+from tkinter import *
+
from agents import *
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
class Gui(VacuumEnvironment):
"""This is a two-dimensional GUI environment. Each location may be
@@ -13,8 +13,10 @@ class Gui(VacuumEnvironment):
xi, yi = (0, 0)
perceptible_distance = 1
- def __init__(self, root, width=7, height=7, elements=['D', 'W']):
+ def __init__(self, root, width=7, height=7, elements=None):
super().__init__(width, height)
+ if elements is None:
+ elements = ['D', 'W']
self.root = root
self.create_frames()
self.create_buttons()
@@ -71,10 +73,10 @@ def display_element(self, button):
def execute_action(self, agent, action):
"""Determines the action the agent performs."""
- xi, yi = ((self.xi, self.yi))
+ xi, yi = (self.xi, self.yi)
if action == 'Suck':
dirt_list = self.list_things_at(agent.location, Dirt)
- if dirt_list != []:
+ if dirt_list:
dirt = dirt_list[0]
agent.performance += 100
self.delete_thing(dirt)
@@ -124,7 +126,7 @@ def update_env(self):
xf, yf = agt.location
def reset_env(self, agt):
- """Resets the GUI environment to the intial state."""
+ """Resets the GUI environment to the initial state."""
self.read_env()
for i, btn_row in enumerate(self.buttons):
for j, btn in enumerate(btn_row):
@@ -166,11 +168,9 @@ def __init__(self, program=None):
self.direction = Direction("up")
-# TODO:
-# Check the coordinate system.
-# Give manual choice for agent's location.
-def main():
- """The main function."""
+# TODO: Check the coordinate system.
+# TODO: Give manual choice for agent's location.
+if __name__ == "__main__":
root = Tk()
root.title("Vacuum Environment")
root.geometry("420x440")
@@ -189,7 +189,3 @@ def main():
next_button.config(command=env.update_env)
reset_button.config(command=lambda: env.reset_env(agt))
root.mainloop()
-
-
-if __name__ == "__main__":
- main()
diff --git a/images/-0.04.jpg b/images/-0.04.jpg
new file mode 100644
index 000000000..3cf276421
Binary files /dev/null and b/images/-0.04.jpg differ
diff --git a/images/-0.4.jpg b/images/-0.4.jpg
new file mode 100644
index 000000000..b274d2ce3
Binary files /dev/null and b/images/-0.4.jpg differ
diff --git a/images/-4.jpg b/images/-4.jpg
new file mode 100644
index 000000000..79eefb0cd
Binary files /dev/null and b/images/-4.jpg differ
diff --git a/images/4.jpg b/images/4.jpg
new file mode 100644
index 000000000..55e75001d
Binary files /dev/null and b/images/4.jpg differ
diff --git a/images/broxrevised.png b/images/broxrevised.png
new file mode 100644
index 000000000..87051a383
Binary files /dev/null and b/images/broxrevised.png differ
diff --git a/images/cake_graph.jpg b/images/cake_graph.jpg
new file mode 100644
index 000000000..160a413ca
Binary files /dev/null and b/images/cake_graph.jpg differ
diff --git a/images/ensemble_learner.jpg b/images/ensemble_learner.jpg
new file mode 100644
index 000000000..b1edd1ec5
Binary files /dev/null and b/images/ensemble_learner.jpg differ
diff --git a/images/ge0.jpg b/images/ge0.jpg
new file mode 100644
index 000000000..a70b18703
Binary files /dev/null and b/images/ge0.jpg differ
diff --git a/images/ge1.jpg b/images/ge1.jpg
new file mode 100644
index 000000000..624f16e25
Binary files /dev/null and b/images/ge1.jpg differ
diff --git a/images/ge2.jpg b/images/ge2.jpg
new file mode 100644
index 000000000..3a29f8f4c
Binary files /dev/null and b/images/ge2.jpg differ
diff --git a/images/ge4.jpg b/images/ge4.jpg
new file mode 100644
index 000000000..b3a4b4acd
Binary files /dev/null and b/images/ge4.jpg differ
diff --git a/images/general_learning_agent.jpg b/images/general_learning_agent.jpg
new file mode 100644
index 000000000..a8153bef8
Binary files /dev/null and b/images/general_learning_agent.jpg differ
diff --git a/images/grid_mdp.jpg b/images/grid_mdp.jpg
new file mode 100644
index 000000000..fa77fa276
Binary files /dev/null and b/images/grid_mdp.jpg differ
diff --git a/images/grid_mdp_agent.jpg b/images/grid_mdp_agent.jpg
new file mode 100644
index 000000000..3f247b6f2
Binary files /dev/null and b/images/grid_mdp_agent.jpg differ
diff --git a/images/hillclimb-tsp.png b/images/hillclimb-tsp.png
new file mode 100644
index 000000000..8446bbafc
Binary files /dev/null and b/images/hillclimb-tsp.png differ
diff --git a/images/knowledge_FOIL_grandparent.png b/images/knowledge_FOIL_grandparent.png
new file mode 100644
index 000000000..dbc6e7729
Binary files /dev/null and b/images/knowledge_FOIL_grandparent.png differ
diff --git a/images/knowledge_foil_family.png b/images/knowledge_foil_family.png
new file mode 100644
index 000000000..356f22d8d
Binary files /dev/null and b/images/knowledge_foil_family.png differ
diff --git a/images/maze.png b/images/maze.png
new file mode 100644
index 000000000..f3fcd1990
Binary files /dev/null and b/images/maze.png differ
diff --git a/images/mdp-b.png b/images/mdp-b.png
new file mode 100644
index 000000000..f21a3760c
Binary files /dev/null and b/images/mdp-b.png differ
diff --git a/images/mdp-c.png b/images/mdp-c.png
new file mode 100644
index 000000000..1034079a2
Binary files /dev/null and b/images/mdp-c.png differ
diff --git a/images/mdp-d.png b/images/mdp-d.png
new file mode 100644
index 000000000..8ba7cf073
Binary files /dev/null and b/images/mdp-d.png differ
diff --git a/images/pop.jpg b/images/pop.jpg
new file mode 100644
index 000000000..52b3e3756
Binary files /dev/null and b/images/pop.jpg differ
diff --git a/images/queen_s.png b/images/queen_s.png
new file mode 100644
index 000000000..cc693102a
Binary files /dev/null and b/images/queen_s.png differ
diff --git a/images/random_forest.png b/images/random_forest.png
new file mode 100644
index 000000000..e0ab1d658
Binary files /dev/null and b/images/random_forest.png differ
diff --git a/images/refinement.png b/images/refinement.png
new file mode 100644
index 000000000..8270d81d0
Binary files /dev/null and b/images/refinement.png differ
diff --git a/images/simple_problem_solving_agent.jpg b/images/simple_problem_solving_agent.jpg
new file mode 100644
index 000000000..80fb904b5
Binary files /dev/null and b/images/simple_problem_solving_agent.jpg differ
diff --git a/images/stapler1-test.png b/images/stapler1-test.png
new file mode 100644
index 000000000..e550d83f9
Binary files /dev/null and b/images/stapler1-test.png differ
diff --git a/improving_sat_algorithms.ipynb b/improving_sat_algorithms.ipynb
new file mode 100644
index 000000000..d461e99c4
--- /dev/null
+++ b/improving_sat_algorithms.ipynb
@@ -0,0 +1,2539 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "pycharm": {}
+ },
+ "source": [
+ "# Propositional Logic\n",
+ "---\n",
+ "# Improving Boolean Satisfiability Algorithms\n",
+ "\n",
+ "## Introduction\n",
+ "A propositional formula $\\Phi$ in *Conjunctive Normal Form* (CNF) is a conjunction of clauses $\\omega_j$, with $j \\in \\{1,...,m\\}$. Each clause being a disjunction of literals and each literal being either a positive ($x_i$) or a negative ($\\lnot{x_i}$) propositional variable, with $i \\in \\{1,...,n\\}$. By denoting with $[\\lnot]$ the possible presence of $\\lnot$, we can formally define $\\Phi$ as:\n",
+ "\n",
+ "$$\\bigwedge_{j = 1,...,m}\\bigg(\\bigvee_{i \\in \\omega_j} [\\lnot] x_i\\bigg)$$\n",
+ "\n",
+ "The ***Boolean Satisfiability Problem*** (SAT) consists in determining whether there exists a truth assignment in $\\{0, 1\\}$ (or equivalently in $\\{True,False\\}$) for the variables in $\\Phi$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from logic import *"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## DPLL with Branching Heuristics\n",
+ "The ***Davis-Putnam-Logemann-Loveland*** (DPLL) algorithm is a *complete* (will answer SAT if a solution exists) and *sound* (it will not answer SAT for an unsatisfiable formula) procedue that combines *backtracking search* and *deduction* to decide satisfiability of propositional logic formula in CNF. At each search step a variable and a propositional value are selected for branching purposes. With each branching step, two values can be assigned to a variable, either 0 or 1. Branching corresponds to assigning the chosen value to the chosen variable. Afterwards, the logical consequences of each branching step are evaluated. Each time an unsatisfied clause (ie a *conflict*) is identified, backtracking is executed. Backtracking corresponds to undoing branching steps until an unflipped branch is reached. When both values have been assigned to the selected variable at a branching step, backtracking will undo this branching step. If for the first branching step both values have been considered, and backtracking undoes this first branching step, then the CNF formula can be declared unsatisfiable. This kind of backtracking is called *chronological backtracking*.\n",
+ "\n",
+ "Essentially, `DPLL` is a backtracking depth-first search through partial truth assignments which uses a *splitting rule* to replaces the original problem with two smaller subproblems, whereas the original Davis-Putnam procedure uses a variable elimination rule which replaces the original problem with one larger subproblem. Over the years, many heuristics have been proposed in choosing the splitting variable (which variable should be assigned a truth value next).\n",
+ "\n",
+ "Search algorithms that are based on a predetermined order of search are called static algorithms, whereas the ones that select them at the runtime are called dynamic. The first SAT search algorithm, the Davis-Putnam procedure is a static algorithm. Static search algorithms are usually very slow in practice and for this reason perform worse than dynamic search algorithms. However, dynamic search algorithms are much harder to design, since they require a heuristic for predetermining the order of search. The fundamental element of a heuristic is a branching strategy for selecting the next branching literal. This must not require a lot of time to compute and yet it must provide a powerful insight into the problem instance.\n",
+ "\n",
+ "Two basic heuristics are applied to this algorithm with the potential of cutting the search space in half. These are the *pure literal rule* and the *unit clause rule*.\n",
+ "- the *pure literal* rule is applied whenever a variable appears with a single polarity in all the unsatisfied clauses. In this case, assigning a truth value to the variable so that all the involved clauses are satisfied is highly effective in the search;\n",
+ "- if some variable occurs in the current formula in a clause of length 1 then the *unit clause* rule is applied. Here, the literal is selected and a truth value so the respective clause is satisfied is assigned. The iterative application of the unit rule is commonly reffered to as *Boolean Constraint Propagation* (BCP)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;32mdef\u001b[0m \u001b[0mdpll_satisfiable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mno_branching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"Check satisfiability of a propositional sentence.\u001b[0m\n",
+ "\u001b[0;34m This differs from the book code in two ways: (1) it returns a model\u001b[0m\n",
+ "\u001b[0;34m rather than True when it succeeds; this is more useful. (2) The\u001b[0m\n",
+ "\u001b[0;34m function find_pure_symbol is passed a list of unknown clauses, rather\u001b[0m\n",
+ "\u001b[0;34m than a list of all clauses and the model; this is more efficient.\u001b[0m\n",
+ "\u001b[0;34m >>> dpll_satisfiable(A |'<=>'| B) == {A: True, B: True}\u001b[0m\n",
+ "\u001b[0;34m True\u001b[0m\n",
+ "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdpll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconjuncts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mto_cnf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop_symbols\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%psource dpll_satisfiable"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;32mdef\u001b[0m \u001b[0mdpll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mno_branching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"See if the clauses are true in a partial model.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0munknown_clauses\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# clauses with an unknown truth value\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mclauses\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpl_true\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0munknown_clauses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0munknown_clauses\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfind_pure_symbol\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munknown_clauses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdpll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mremove_all\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfind_unit_clause\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdpll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mremove_all\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munknown_clauses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdpll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mremove_all\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mdpll\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mremove_all\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbranching_heuristic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%psource dpll"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Each of these branching heuristics was applied only after the *pure literal* and the *unit clause* heuristic failed in selecting a splitting variable."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### MOMs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "MOMs heuristics are simple, efficient and easy to implement. The goal of these heuristics is to prefer the literal having ***Maximum number of Occurences in the Minimum length clauses***. Intuitively, the literals belonging to the minimum length clauses are the most constrained literals in the formula. Branching on them will maximize the effect of BCP and the likelihood of hitting a dead end early in the search tree (for unsatisfiable problems). Conversely, in the case of satisfiable formulas, branching on a highly constrained variable early in the tree will also increase the likelihood of a correct assignment of the remained open literals.\n",
+ "The MOMs heuristics main disadvatage is that their effectiveness highly depends on the problem instance. It is easy to see that the ideal setting for these heuristics is considering the unsatisfied binary clauses."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;32mdef\u001b[0m \u001b[0mmin_clauses\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mmin_len\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclauses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefault\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mmin_len\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmin_len\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclauses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%psource min_clauses"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;32mdef\u001b[0m \u001b[0mmoms\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclauses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"\u001b[0m\n",
+ "\u001b[0;34m MOMS (Maximum Occurrence in clauses of Minimum Size) heuristic\u001b[0m\n",
+ "\u001b[0;34m Returns the literal with the most occurrences in all clauses of minimum size\u001b[0m\n",
+ "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCounter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmin_clauses\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mprop_symbols\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0msymbol\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%psource moms"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Over the years, many types of MOMs heuristics have been proposed.\n",
+ "\n",
+ "***MOMSf*** choose the variable $x$ with a maximize the function:\n",
+ "\n",
+ "$$[f(x) + f(\\lnot{x})] * 2^k + f(x) * f(\\lnot{x})$$\n",
+ "\n",
+ "where $f(x)$ is the number of occurrences of $x$ in the smallest unknown clauses, k is a parameter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\u001b[0;32mdef\u001b[0m \u001b[0mmomsf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclauses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"\u001b[0m\n",
+ "\u001b[0;34m MOMS alternative heuristic\u001b[0m\n",
+ "\u001b[0;34m If f(x) the number of occurrences of the variable x in clauses with minimum size,\u001b[0m\n",
+ "\u001b[0;34m we choose the variable maximizing [f(x) + f(-x)] * 2^k + f(x) * f(-x)\u001b[0m\n",
+ "\u001b[0;34m Returns x if f(x) >= f(-x) otherwise -x\u001b[0m\n",
+ "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCounter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmin_clauses\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclauses\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdisjuncts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mP\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0msymbol\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m~\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mpow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m~\u001b[0m\u001b[0msymbol\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
+ "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mTrue\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m~\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%psource momsf"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "***Freeman’s POSIT***