aimacode · antmarakis · Dec 14, 2019 · Mar 24, 2019 · Mar 28, 2019 · Apr 11, 2019
diff --git a/agents.py b/agents.py
@@ -354,8 +354,7 @@ def list_things_at(self, location, tclass=Thing):
             return [thing for thing in self.things
                     if thing.location == location and isinstance(thing, tclass)]
         return [thing for thing in self.things
-                if all(x==y for x,y in zip(thing.location, location))
-                    and isinstance(thing, tclass)]
+                if all(x == y for x, y in zip(thing.location, location)) and isinstance(thing, tclass)]
 
     def some_things_at(self, location, tclass=Thing):
         """Return true if at least one of the things at location

diff --git a/agents4e.py b/agents4e.py
@@ -354,8 +354,7 @@ def list_things_at(self, location, tclass=Thing):
             return [thing for thing in self.things
                     if thing.location == location and isinstance(thing, tclass)]
         return [thing for thing in self.things
-                if all(x==y for x,y in zip(thing.location, location))
-                    and isinstance(thing, tclass)]
+                if all(x == y for x, y in zip(thing.location, location)) and isinstance(thing, tclass)]
 
     def some_things_at(self, location, tclass=Thing):
         """Return true if at least one of the things at location

diff --git a/deep_learning4e.py b/deep_learning4e.py
@@ -1,9 +1,9 @@
 """Deep learning. (Chapters 20)"""
 
-import math
 import random
 import statistics
 
+import numpy as np
 from keras import Sequential, optimizers
 from keras.layers import Embedding, SimpleRNN, Dense
 from keras.preprocessing import sequence
@@ -249,7 +249,7 @@ def adam(dataset, net, loss, epochs=1000, rho=(0.9, 0.999), delta=1 / 10 ** 8,
             r_hat = scalar_vector_product(1 / (1 - rho[1] ** t), r)
 
             # rescale r_hat
-            r_hat = map_vector(lambda x: 1 / (math.sqrt(x) + delta), r_hat)
+            r_hat = map_vector(lambda x: 1 / (np.sqrt(x) + delta), r_hat)
 
             # delta weights
             delta_theta = scalar_vector_product(-l_rate, element_wise_product(s_hat, r_hat))
@@ -341,7 +341,7 @@ def forward(self, inputs):
         res = []
         # get normalized value of each input
         for i in range(len(self.nodes)):
-            val = [(inputs[i] - mu) * self.weights[0] / math.sqrt(self.epsilon + stderr ** 2) + self.weights[1]]
+            val = [(inputs[i] - mu) * self.weights[0] / np.sqrt(self.epsilon + stderr ** 2) + self.weights[1]]
             res.append(val)
             self.nodes[i].val = val
         return res

diff --git a/games.py b/games.py
@@ -1,11 +1,13 @@
-"""Games or Adversarial Search. (Chapter 5)"""
+"""Games or Adversarial Search (Chapter 5)"""
 
 import copy
 import itertools
 import random
 from collections import namedtuple
 
-from utils import vector_add, inf
+import numpy as np
+
+from utils import vector_add
 
 GameState = namedtuple('GameState', 'to_move, utility, board, moves')
 StochasticGameState = namedtuple('StochasticGameState', 'to_move, utility, board, moves, chance')
@@ -24,15 +26,15 @@ def minmax_decision(state, game):
     def max_value(state):
         if game.terminal_test(state):
             return game.utility(state, player)
-        v = -inf
+        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 = inf
+        v = np.inf
         for a in game.actions(state):
             v = min(v, max_value(game.result(state, a)))
         return v
@@ -53,13 +55,13 @@ def expect_minmax(state, game):
     player = game.to_move(state)
 
     def max_value(state):
-        v = -inf
+        v = -np.inf
         for a in game.actions(state):
             v = max(v, chance_node(state, a))
         return v
 
     def min_value(state):
-        v = inf
+        v = np.inf
         for a in game.actions(state):
             v = min(v, chance_node(state, a))
         return v
@@ -94,7 +96,7 @@ def alpha_beta_search(state, game):
     def max_value(state, alpha, beta):
         if game.terminal_test(state):
             return game.utility(state, player)
-        v = -inf
+        v = -np.inf
         for a in game.actions(state):
             v = max(v, min_value(game.result(state, a), alpha, beta))
             if v >= beta:
@@ -105,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 = inf
+        v = np.inf
         for a in game.actions(state):
             v = min(v, max_value(game.result(state, a), alpha, beta))
             if v <= alpha:
@@ -114,8 +116,8 @@ def min_value(state, alpha, beta):
         return v
 
     # Body of alpha_beta_search:
-    best_score = -inf
-    beta = inf
+    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)
@@ -135,7 +137,7 @@ def alpha_beta_cutoff_search(state, game, d=4, cutoff_test=None, eval_fn=None):
     def max_value(state, alpha, beta, depth):
         if cutoff_test(state, depth):
             return eval_fn(state)
-        v = -inf
+        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:
@@ -146,7 +148,7 @@ def max_value(state, alpha, beta, depth):
     def min_value(state, alpha, beta, depth):
         if cutoff_test(state, depth):
             return eval_fn(state)
-        v = inf
+        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:
@@ -158,8 +160,8 @@ def min_value(state, alpha, beta, depth):
     # 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 = -inf
-    beta = inf
+    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)

diff --git a/games4e.py b/games4e.py
@@ -1,11 +1,13 @@
-"""Games or Adversarial Search. (Chapter 5)"""
+"""Games or Adversarial Search (Chapter 5)"""
 
 import copy
 import itertools
 import random
 from collections import namedtuple
 
-from utils4e import vector_add, MCT_Node, ucb, inf
+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')
@@ -24,15 +26,15 @@ def minmax_decision(state, game):
     def max_value(state):
         if game.terminal_test(state):
             return game.utility(state, player)
-        v = -inf
+        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 = inf
+        v = np.inf
         for a in game.actions(state):
             v = min(v, max_value(game.result(state, a)))
         return v
@@ -53,13 +55,13 @@ def expect_minmax(state, game):
     player = game.to_move(state)
 
     def max_value(state):
-        v = -inf
+        v = -np.inf
         for a in game.actions(state):
             v = max(v, chance_node(state, a))
         return v
 
     def min_value(state):
-        v = inf
+        v = np.inf
         for a in game.actions(state):
             v = min(v, chance_node(state, a))
         return v
@@ -94,7 +96,7 @@ def alpha_beta_search(state, game):
     def max_value(state, alpha, beta):
         if game.terminal_test(state):
             return game.utility(state, player)
-        v = -inf
+        v = -np.inf
         for a in game.actions(state):
             v = max(v, min_value(game.result(state, a), alpha, beta))
             if v >= beta:
@@ -105,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 = inf
+        v = np.inf
         for a in game.actions(state):
             v = min(v, max_value(game.result(state, a), alpha, beta))
             if v <= alpha:
@@ -114,8 +116,8 @@ def min_value(state, alpha, beta):
         return v
 
     # Body of alpha_beta_search:
-    best_score = -inf
-    beta = inf
+    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)
@@ -135,7 +137,7 @@ def alpha_beta_cutoff_search(state, game, d=4, cutoff_test=None, eval_fn=None):
     def max_value(state, alpha, beta, depth):
         if cutoff_test(state, depth):
             return eval_fn(state)
-        v = -inf
+        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:
@@ -146,7 +148,7 @@ def max_value(state, alpha, beta, depth):
     def min_value(state, alpha, beta, depth):
         if cutoff_test(state, depth):
             return eval_fn(state)
-        v = inf
+        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:
@@ -158,8 +160,8 @@ def min_value(state, alpha, beta, depth):
     # 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 = -inf
-    beta = inf
+    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)

diff --git 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_graph_search as bfs, uniform_cost_search as ucs, \
-    astar_search as asts
 from utils import PriorityQueue
-from copy import deepcopy
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
 root = None
 city_coord = {}
@@ -289,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")
 
@@ -325,13 +320,11 @@ def tree_search(problem):
         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
 
@@ -562,7 +555,7 @@ 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.
@@ -572,47 +565,47 @@ def on_click():
     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")
         counter += 1
     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 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")
         counter += 1
     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")
         counter += 1
     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")
         counter += 1
     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")
@@ -626,6 +619,7 @@ def reset_map():
         city_map.itemconfig(city_coord[city], fill="white")
     next_button.config(state="normal")
 
+
 # TODO: Add more search algorithms in the OptionMenu