aima-python/search_vis.py at master · gobber/aima-python · GitHub

History

217 lines (184 loc) · 7.67 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

from search import *

# Essa é uma busca em profundidade com

# alguns adicionais, mas a ideia

# é a mesma da busca tradicional

# que é baseada em uma Pilha e uma

# estrutura de explorados.

def graph_search_for_vis(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."""

# we use these two variables at the time of visualisations

iterations = 0

all_node_colors = []

node_colors = {k : 'white' for k in problem.graph.nodes()}

frontier = [(Node(problem.initial))]

explored = set()

# modify the color of frontier nodes to orange

node_colors[Node(problem.initial).state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

while frontier:

# Popping first node of stack

node = frontier.pop()

# modify the currently searching node to red

node_colors[node.state] = "red"

iterations += 1

all_node_colors.append(dict(node_colors))

if problem.goal_test(node.state):

# modify goal node to green after reaching the goal

node_colors[node.state] = "green"

iterations += 1

all_node_colors.append(dict(node_colors))

return(iterations, all_node_colors, 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)

for n in frontier:

# modify the color of frontier nodes to orange

node_colors[n.state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

# modify the color of explored nodes to gray

node_colors[node.state] = "gray"

iterations += 1

all_node_colors.append(dict(node_colors))

return None

def depth_first_graph_search(problem):

"""Search the deepest nodes in the search tree first."""

iterations, all_node_colors, node = graph_search_for_vis(problem)

return(iterations, all_node_colors, node)

# Essa é uma busca em largura com

# alguns adicionais, mas a ideia

# é a mesma da busca tradicional

# que é baseada em uma Fila e uma

# estrutura de explorados.

def breadth_first_search_graph(problem):

# we use these two variables at the time of visualisations

iterations = 0

all_node_colors = []

node_colors = {k : 'white' for k in problem.graph.nodes()}

node = Node(problem.initial)

node_colors[node.state] = "red"

iterations += 1

all_node_colors.append(dict(node_colors))

if problem.goal_test(node.state):

node_colors[node.state] = "green"

iterations += 1

all_node_colors.append(dict(node_colors))

return(iterations, all_node_colors, node)

frontier = deque([node])

# modify the color of frontier nodes to blue

node_colors[node.state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

explored = set()

while frontier:

node = frontier.popleft()

node_colors[node.state] = "red"

iterations += 1

all_node_colors.append(dict(node_colors))

explored.add(node.state)

for child in node.expand(problem):

if child.state not in explored and child not in frontier:

if problem.goal_test(child.state):

node_colors[child.state] = "green"

iterations += 1

all_node_colors.append(dict(node_colors))

return(iterations, all_node_colors, child)

frontier.append(child)

node_colors[child.state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

node_colors[node.state] = "gray"

iterations += 1

all_node_colors.append(dict(node_colors))

return None

# Muitos algoritmos de busca heurísticos diferem apenas da função

# heurística que utilizam, portanto podemos fazer uma função geral

# é exatamente isso que essa função faz. Ela serve para implementar

# o algoritmo guloso e o A*, além de outros como o de Dijkstra.

def best_first_graph_search_for_vis(problem, f):

"""Search the nodes with the lowest f scores first.

You specify the function f(node) that you want to minimize; for example,

if f is a heuristic estimate to the goal, then we have greedy best

first search; if f is node.depth then we have breadth-first search.

There is a subtlety: the line "f = memoize(f, 'f')" means that the f

values will be cached on the nodes as they are computed. So after doing

a best first search you can examine the f values of the path returned."""

# we use these two variables at the time of visualisations

iterations = 0

all_node_colors = []

node_colors = {k : 'white' for k in problem.graph.nodes()}

f = memoize(f, 'f')

node = Node(problem.initial)

node_colors[node.state] = "red"

iterations += 1

all_node_colors.append(dict(node_colors))

if problem.goal_test(node.state):

node_colors[node.state] = "green"

iterations += 1

all_node_colors.append(dict(node_colors))

return(iterations, all_node_colors, node)

frontier = PriorityQueue('min', f)

frontier.append(node)

node_colors[node.state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

explored = set()

while frontier:

node = frontier.pop()

node_colors[node.state] = "red"

iterations += 1

all_node_colors.append(dict(node_colors))

if problem.goal_test(node.state):

node_colors[node.state] = "green"

iterations += 1

all_node_colors.append(dict(node_colors))

return(iterations, all_node_colors, node)

explored.add(node.state)

for child in node.expand(problem):

if child.state not in explored and child not in frontier:

frontier.append(child)

node_colors[child.state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

elif child in frontier:

incumbent = frontier[child]

if f(child) < incumbent:

del incumbent

frontier.append(child)

node_colors[child.state] = "orange"

iterations += 1

all_node_colors.append(dict(node_colors))

node_colors[node.state] = "gray"

iterations += 1

all_node_colors.append(dict(node_colors))

return None

# Algoritmo de busca gulosa.

def greedy_best_first_search(problem, h=None):

"""Greedy Best-first graph search is an informative searching algorithm with f(n) = h(n).

You need to specify the h function when you call best_first_search, or

else in your Problem subclass."""

h = memoize(h or problem.h, 'h')

iterations, all_node_colors, node = best_first_graph_search_for_vis(problem, lambda n: h(n))

return(iterations, all_node_colors, node)

# Algoritmo A*

def astar_search_graph(problem, h=None):

"""A* search is best-first graph search with f(n) = g(n)+h(n).

You need to specify the h function when you call astar_search, or

else in your Problem subclass."""

h = memoize(h or problem.h, 'h')

iterations, all_node_colors, node = best_first_graph_search_for_vis(problem, lambda n: n.path_cost + h(n))

return(iterations, all_node_colors, node)

aima-python/search_vis.py at master · gobber/aima-python · GitHub

Expand file tree

Breadcrumbs

search_vis.py

Latest commit

History

Breadcrumbs

search_vis.py

File metadata and controls