def beam_search(self, graph, source, destination, beam_width):
print(f'doing beam search with beam width: {beam_width}')
path = []
for edge in nx.bfs_beam_edges(graph, source, lambda _: 1, beam_width):
if edge[1] != destination:
path.append(edge[1])
else:
break
print(f'beam search cost: {len(path)}')
def test_narrow(self):
"""Tests that a narrow beam width may cause an incomplete search."""
# In this search, we enqueue only the neighbor 3 at the first
# step, then only the neighbor 2 at the second step. Once at
# node 2, the search chooses node 3, since it has a higher value
# that node 1, but node 3 has already been visited, so the
# search terminates.
G = nx.cycle_graph(4)
edges = nx.bfs_beam_edges(G, 0, identity, width=1)
assert_equal(list(edges), [(0, 3), (3, 2)])
def test_narrow(self):
"""Tests that a narrow beam width may cause an incomplete search."""
# In this search, we enqueue only the neighbor 3 at the first
# step, then only the neighbor 2 at the second step. Once at
# node 2, the search chooses node 3, since it has a higher value
# that node 1, but node 3 has already been visited, so the
# search terminates.
G = nx.cycle_graph(4)
edges = nx.bfs_beam_edges(G, 0, identity, width=1)
assert list(edges) == [(0, 3), (3, 2)]
def progressive_widening_search(a: nx.classes.graph.Graph, s: int, v, con: Callable[[int], bool], initial_width: int = 1) -> int:
if con(s):
return s
log_m = math.ceil(math.log2((len(a))))
for i in range(log_m):
width = initial_width * pow(2, i)
for u, v in nx.bfs_beam_edges(a, s, v, width):
if con(v):
return v
print(nx.NodeNotFound("no node"))
def progressive_widening_search(G, source, value, condition, initial_width=1):
if condition(source):
return source
log_m = math.ceil(math.log2(len(G)))
for i in range(log_m):
width = initial_width * pow(2, i)
for u, v in nx.bfs_beam_edges(G, source, value, width):
if condition(v):
return v
raise nx.NodeNotFound("no node satisfied the termination condition")
def progressive_widening_search(G, source, value, condition, initial_width=1):
"""Progressive widening beam search to find a node.
The progressive widening beam search involves a repeated beam
search, starting with a small beam width then extending to
progressively larger beam widths if the target node is not
found. This implementation simply returns the first node found that
matches the termination condition.
`G` is a NetworkX graph.
`source` is a node in the graph. The search for the node of interest
begins here and extends only to those nodes in the (weakly)
connected component of this node.
`value` is a function that returns a real number indicating how good
a potential neighbor node is when deciding which neighbor nodes to
enqueue in the breadth-first search. Only the best nodes within the
current beam width will be enqueued at each step.
`condition` is the termination condition for the search. This is a
function that takes a node as input and return a Boolean indicating
whether the node is the target. If no node matches the termination
condition, this function raises :exc:`NodeNotFound`.
`initial_width` is the starting beam width for the beam search (the
default is one). If no node matching the `condition` is found with
this beam width, the beam search is restarted from the `source` node
with a beam width that is twice as large (so the beam width
increases exponentially). The search terminates after the beam width
exceeds the number of nodes in the graph.
"""
# Check for the special case in which the source node satisfies the
# termination condition.
if condition(source):
return source
# The largest possible value of `i` in this range yields a width at
# least the number of nodes in the graph, so the final invocation of
# `bfs_beam_edges` is equivalent to a plain old breadth-first
# search. Therefore, all nodes will eventually be visited.
#
# TODO In Python 3.3+, this should be `math.log2(len(G))`.
log_m = math.ceil(math.log(len(G), 2))
for i in range(log_m):
width = initial_width * pow(2, i)
# Since we are always starting from the same source node, this
# search may visit the same nodes many times (depending on the
# implementation of the `value` function).
for u, v in nx.bfs_beam_edges(G, source, value, width):
if condition(v):
return v
# At this point, since all nodes have been visited, we know that
# none of the nodes satisfied the termination condition.
raise nx.NodeNotFound('no node satisfied the termination condition')
def neighbors_graph(ingraph, source, beamwidth=4, maxnodes=10):
""" Neighbors of source node in ingraph """
assert ingraph.is_directed(), "not implemented for undirected graphs"
centrality = nx.eigenvector_centrality_numpy(
ingraph) # max_iter=10 tol=0.1
outgraph = nx.MultiDiGraph()
for u, v in nx.bfs_beam_edges(ingraph, source, centrality.get, beamwidth):
if isinstance(ingraph, nx.MultiDiGraph):
outgraph.add_edge(u, v, key=0, **(ingraph.get_edge_data(u, v)[0]))
else:
outgraph.add_edge(u, v, **(ingraph.get_edge_data(u, v)))
if outgraph.number_of_nodes() >= maxnodes:
break
return outgraph
def test_wide(self):
G = nx.cycle_graph(4)
edges = nx.bfs_beam_edges(G, 0, identity, width=2)
assert_equal(list(edges), [(0, 3), (0, 1), (3, 2)])
def test_wide(self):
G = nx.cycle_graph(4)
edges = nx.bfs_beam_edges(G, 0, identity, width=2)
assert list(edges) == [(0, 3), (0, 1), (3, 2)]
corner_tiles = [n[0] for n in G.degree() if n[1] == 2]
print(f"Product of edge tile ids: {math.prod(corner_tiles)}")
#%% Part 2
visited = {corner_tiles[0]}
def tile_score(x: int) -> int:
return visited.add(x) or -sum(n in visited for n in G.neighbors(x))
c0 = corner_tiles[0]
tile_ids = [c0] + [v for _, v in nx.bfs_beam_edges(G, c0, tile_score, 4)]
tile_map = np.zeros((12, 12), dtype=int)
idx = np.argsort(np.add.outer(np.arange(12), np.arange(12)).ravel(), kind="stable")
tile_map.ravel()[idx] = np.array(tile_ids)
result = np.zeros((12*8, 12*8), dtype=int)
top_left_tile: ImageTile = tiles[tile_map[0, 0]]
top_left_tile.match_right(G.get_edge_data(tile_map[0, 0], tile_map[0, 1])["border"])
if top_left_tile.borders()[1] != G.get_edge_data(tile_map[0, 0], tile_map[1, 0])["border"]:
top_left_tile.flip()
result[0:8, 0:8] = top_left_tile.data[1:9, 1:9]
for y in range(1, 12):
tile_above: ImageTile = tiles[tile_map[y-1, 0]]
tile: ImageTile = tiles[tile_map[y, 0]]
plt.savefig("Session8 Graph c BFS.png")
plt.title("Graph c BFS algorithm" , color='blue', fontweight='bold')
plt.show()
Successors=nx.bfs_successors(c_G,'B')
print("Successors: ",dict(Successors))
Predecessors=nx.bfs_predecessors(c_G,'B')
print("Predecessors: ",dict(Predecessors))
""" Beam seach algorithm of Graph a with the width=2"""
print("###Grapg info and result of beam search of graph a############################")
print(nx.info(a_G))
eigen_centra=nx.eigenvector_centrality(a_G)
source = 'A'
width = 2
bfs_beam_edges=nx.bfs_beam_edges(a_G, source, eigen_centra.get, width)
beam_graph=nx.DiGraph()
beam_graph.add_edges_from(bfs_beam_edges)
print("\n Beam Search Result: ",list(beam_graph.edges))
color_map=[]
for node in beam_graph:
if node =='A':
color_map.append('pink')
else:
color_map.append('blue')
figure(num=None, figsize=(14, 6), dpi=80, facecolor='w', edgecolor='k')
plt.subplot(121)
nx.draw(beam_graph, with_labels=True, node_color=color_map,node_size=500)
