def risk(self, paths, snakes):
# for each point in a path, calculate distance to other snakes
# for each path, the score is the sum of all distances. greater is better
# return {path1: score, path2: score, ...}
board_with_heads = self.make_board_with_heads(snakes)
_heuristic = chow(*paths.keys())
_heuristic.optimize(board_with_heads)
return dict([(food, self._risk(_heuristic, board_with_heads, paths[food], snakes)) for food in paths.keys()])
def search_A_star(self, sentence):
tokens = nltk.word_tokenize(sentence)
#if a node does not exist, it shall be added to the graph and connected to the previous node
for i, token in enumerate(tokens):
if not self.net.has_node(token):
self.net.add_node(str(token))
#print "adding node", token
#if the edge does not exist between the current node and the previous one, an edge shall be added
if i != 0:
edge = (tokens[i - 1], token)
if not self.net.has_edge(edge):
self.net.add_edge(edge,
wt=self.EDGE_START_WEIGHT,
label=self.START_OCCURRENCES_NUM)
h = chow(
tokens[0]
) #this optimization shall be performed chooosing a term which is connected: the choice of this term shall be performed accoding to some rule
h.optimize(self.net)
path = ''
for k, token in enumerate(tokens):
if k != 0:
try:
intermediate_node_path = heuristic_search(
self.net, tokens[k - 1], token,
h) #the path between each couple
except NodeUnreachable, e:
print str(e)
print "NODE UREACHABLE"
for j, node in enumerate(
intermediate_node_path
): #increase the weight of the edges in the path
if j != 0:
edge = (intermediate_node_path[j - 1], node)
if not self.net.has_edge(edge):
raise Exception('edge not found')
else: #if the edge exists, its weight is divided by the number of occurrences stored in the label
number_of_occurrences = self.net.edge_label(edge)
new_number_of_occurrences = number_of_occurrences + 1
self.net.set_edge_label(edge,
new_number_of_occurrences)
self.net.set_edge_weight(edge,
wt=1.0 /
new_number_of_occurrences)
if k < len(tokens) - 1:
#we remove the last element to prevent repetitions of head and tail in the subsequences of the final path
path = path + ' ' + ' '.join(intermediate_node_path[0:-1])
else:
path = path + ' ' + ' '.join(intermediate_node_path)
def pathgen(graph):
"""Calculates the shortest path from each node to each other node."""
# grnodes = len(graph.nodes())
h = chow(1) # Needed for heuristic_search()
h.optimize(graph)
paths = [[] for x in range(len(graph.nodes()))]
for j in graph.nodes():
for i in graph.nodes():
paths[j].append(heuristic_search(graph, j, i, h))
return paths
def test_chow_unreachable(self):
heuristic = chow( "Wales", "North Korea", "Russia" )
self.G.add_node("Sealand")
self.G.add_edge("England", "Sealand")
heuristic.optimize(self.G)
self.G.del_edge("England", "Sealand")
try:
result = pygraph.algorithms.minmax.heuristic_search( self.G, "England", "Sealand" , heuristic )
except exceptions.NodeUnreachable, _:
return
def test_chow_unreachable(self):
heuristic = chow( "Wales", "North Korea", "Russia" )
self.G.add_node("Sealand")
self.G.add_edge(("England", "Sealand"))
heuristic.optimize(self.G)
self.G.del_edge(("England", "Sealand"))
try:
result = pygraph.algorithms.minmax.heuristic_search( self.G, "England", "Sealand" , heuristic )
except exceptions.NodeUnreachable as _:
return
assert False, "This test should raise an unreachable error."
def run_benchmark(self):
G = self.fn_create()
self.generate(G, self.GRAPH_ORDER, self.GRAPH_EDGES)
reference_nodes = sample( G.nodes(), self.CHOW_REFERENCE_POINTS )
heuristic = chow( *reference_nodes )
heuristic.optimize(G)
source_nodes = sample( G.nodes(), self.NUMBER_OF_SEARCHES )
dest_nodes = sample( G.nodes(), self.NUMBER_OF_SEARCHES )
for s,d in zip( source_nodes, dest_nodes ):
log.debug("Searching from %s to %s" % (s,d) )
result = heuristic_search( G, s, d, heuristic )
def test_chow_unreachable(self):
heuristic = chow("Wales", "North Korea", "Russia")
self.G.add_node("Sealand")
self.G.add_edge(("England", "Sealand"))
heuristic.optimize(self.G)
self.G.del_edge(("England", "Sealand"))
try:
result = pygraph.algorithms.minmax.heuristic_search(
self.G, "England", "Sealand", heuristic)
except exceptions.NodeUnreachable as _:
return
assert False, "This test should raise an unreachable error."
def a_star(self, targets):
paths = {}
distances = {}
heuristic = chow(*targets)
heuristic.optimize(self.board)
for target in targets:
try:
paths[target] = heuristic_search(self.board, tuple(self.snake["coords"][0]), target, heuristic)
paths[target] = paths[target][1:] # remove first (current position)
distances[target] = len(paths[target])
except Exception as e:
distances[target] = sys.maxint
print("ERROR %s" % e)
pass
return paths, distances
def search_A_star(self, sentence):
tokens = nltk.word_tokenize(sentence)
#if a node does not exist, it shall be added to the graph and connected to the previous node
for i, token in enumerate(tokens):
if not self.net.has_node(token):
self.net.add_node(str(token))
#print "adding node", token
#if the edge does not exist between the current node and the previous one, an edge shall be added
if i!=0:
edge = (tokens[i-1], token)
if not self.net.has_edge(edge):
self.net.add_edge(edge, wt=self.EDGE_START_WEIGHT, label = self.START_OCCURRENCES_NUM)
h = chow(tokens[0]) #this optimization shall be performed chooosing a term which is connected: the choice of this term shall be performed accoding to some rule
h.optimize(self.net)
path = ''
for k, token in enumerate(tokens):
if k!=0:
try:
intermediate_node_path = heuristic_search(self.net, tokens[k-1], token, h) #the path between each couple
except NodeUnreachable, e:
print str(e)
print "NODE UREACHABLE"
for j, node in enumerate(intermediate_node_path): #increase the weight of the edges in the path
if j != 0:
edge = (intermediate_node_path[j-1], node)
if not self.net.has_edge(edge):
raise Exception('edge not found')
else: #if the edge exists, its weight is divided by the number of occurrences stored in the label
number_of_occurrences = self.net.edge_label(edge)
new_number_of_occurrences = number_of_occurrences + 1
self.net.set_edge_label(edge, new_number_of_occurrences)
self.net.set_edge_weight(edge, wt = 1.0/new_number_of_occurrences)
if k < len(tokens)-1:
#we remove the last element to prevent repetitions of head and tail in the subsequences of the final path
path = path + ' ' + ' '.join(intermediate_node_path[0:-1])
else:
path = path + ' ' + ' '.join(intermediate_node_path)
def test_chow(self):
heuristic = chow( "Wales", "North Korea", "Russia" )
heuristic.optimize(self.G)
result = pygraph.algorithms.minmax.heuristic_search( self.G, "England", "India", heuristic )
def build_path(self, g):
h = chow(self.qinit, self.nearest_qgoal_node)
h.optimize(g)
h_search = heuristic_search
self.path = h_search(g, self.qinit, self.nearest_qgoal_node, h)
def test_chow(self):
heuristic = chow("Wales", "North Korea", "Russia")
heuristic.optimize(self.G)
result = pygraph.algorithms.minmax.heuristic_search(
self.G, "England", "India", heuristic)
def build_path(self, g):
h = chow(self.qinit, self.nearest_qgoal_node)
h.optimize(g)
h_search = heuristic_search
self.path = h_search(g, self.qinit, self.nearest_qgoal_node, h)