def travel_maze(player, world, traversal_path):
visited = set()
cache = {}
while len(visited) != len(world.rooms):
current = player.current_room
unvisited = []
visited.add(current)
travel_dead_ends(player, player.current_room, visited, traversal_path)
possible_paths = utils.get_neighbors(player.current_room)
end_loops = []
others = []
for direction, room in possible_paths.items():
if room not in visited:
unvisited.append([room, direction])
if unvisited:
for room, direction in unvisited:
total = 0
possible_paths = utils.get_neighbors(player.current_room)
if possible_paths and len(possible_paths) > 1:
for direction2, room2 in possible_paths.items():
if room != room2:
check = utils.get_island_entrance(
room, room2, player.current_room)
if check:
total += 1
others.append([room, direction])
if total == 0:
end_loops.append([room, direction])
if end_loops:
best_direction = None
best = None
length_of_best = float('inf')
for room, direction in end_loops:
now = bft(room, player.current_room)
if now < length_of_best:
length_of_best = now
best = room
best_direction = direction
player.travel(best_direction)
traversal_path.append(best_direction)
visited.add(best)
elif others:
player.travel(others[0][1])
traversal_path.append(others[0][1])
visited.add(others[0][0])
else:
utils.bft(player, traversal_path, visited)
return traversal_path
def __create_forest(self):
"""
Create randomly shaped, randomly placed forest in a map.
Private method.
"""
# find suitable start point
start_x = random.randint(0, self.GRID_X-1)
start_y = random.randint(0, self.GRID_Y-1)
if self.map[start_x][start_y]["castle"]:
self.__create_forest()
return
# generate points of forest
forest_points = []
for i in range(self.FOREST_SIZE):
if i == 0:
forest_points.append((start_x, start_y))
else:
# get neighbors of current points and pick random suitable one
neighbors = utils.get_neighbors(forest_points,
(self.GRID_X, self.GRID_Y))
point = neighbors[random.randint(0, len(neighbors)-1)]
while self.map[point[0]][point[1]]["castle"]:
point = neighbors[random.randint(0, len(neighbors)-1)]
neighbors.remove(point)
while self.map[point[0]][point[1]]["village"]:
point = neighbors[random.randint(0, len(neighbors)-1)]
neighbors.remove(point)
forest_points.append(point)
# put points on map
for point in forest_points:
self.map[point[0]][point[1]]["forest"] = True
def simulated_anealing(graph, step=10000, a=0.5, q=1000, t=50, t_min=0.000001, count_max=100):
count = 0
n = len(graph)
s = np.random.permutation(n).tolist() # initil solution
for i in range(step):
s_next = find_better_solusion(get_neighbors(s), s, graph)
e = get_cost(s, graph)
e_next = get_cost(s_next, graph)
if s == s_next:
count += 1
else:
count = 0
if e_next < e:
s = s_next
else:
if random.random() <= probability(e, e_next, t):
s = s_next
if i % q == 0: # Equilibrium state
t = a * t
if count > count_max:
return s
return s
def tabu_search(graph, tabu_max=500, step=10000, count_max=100):
count = 0
tabu_list = []
n = len(graph)
s = np.random.permutation(n).tolist() # initil solution
tabu_list.append(s)
for i in range(step):
feisible_list = []
neighbors = get_neighbors(s)
for x in neighbors:
if not x in tabu_list:
feisible_list.append(x)
s_next = find_better_solusion(feisible_list, s, graph)
if s == s_next:
count += 1
else:
count = 0
s = s_next
if not s in tabu_list:
tabu_list.append(s)
if len(tabu_list) > tabu_max:
tabu_list.pop(0)
if count > count_max:
return s
return s
def a_star_algorithm(self, f):
open_nodes = [self.root]
while True:
curr_node = self.get_minor_node(open_nodes)
if self.max_nodes < len(open_nodes):
self.max_nodes = len(open_nodes)
if np.array_equal(curr_node.get_board(), self.sorted_matrix):
self.solution_path = utils.get_solution(curr_node)
self.memory_usage = self.determine_memory_usage()
return
neighbors = utils.get_neighbors(curr_node.get_board(),
self.board_size)
for neighbor in neighbors:
new_board = utils.swap_position(
copy.copy(curr_node.get_board()), neighbor)
new_node = node.Node(
curr_node,
curr_node.get_board()[neighbor[0]][neighbor[1]],
curr_node.get_depth() + 1, new_board)
new_node.set_h_cost(f(new_node.get_board(), self.board_size))
if new_node.get_value() != new_node.get_upper().get_value():
open_nodes.append(new_node)
def search_a_star(self, initial_x, initial_y, final_x, final_y):
openn = []
closed = []
parents = {}
start = (initial_x, initial_y)
goal = (final_x, final_y)
start_distances = {}
goal_distances = {}
openn.append(start)
parents[start] = None
start_distances[start] = 0
while openn:
current = min(openn, key=lambda o: start_distances.get(
o, 0) + goal_distances.get(o, 0))
if current == goal:
path = []
path.append(current)
while parents[current]:
current = parents[current]
path.append(current)
return path[::-1]
openn.remove(current)
closed.append(current)
neigbhors = utils.get_neighbors(
self.__repository.mapp, current[0], current[1])
for node in neigbhors:
if node in closed:
continue
new_distance = start_distances[current] + 1
if node in openn:
if start_distances[node] > new_distance:
start_distances[node] = new_distance
parents[node] = current
else:
start_distances[node] = new_distance
goal_distances[node] = utils.manhattan(
node[0], node[1], goal[0], goal[1])
parents[node] = current
openn.append(node)
return []
def index():
if request.method == 'POST':
v = int(request.form['number'])
values = get_neighbors(v, zipcodes)
print(values)
results = User.query.filter(User.zipcode.in_(values)).all()
print(results)
return render_template('welcome.html',
string='Make Friends by Zipcode',
value=v,
values=values)
return render_template('index.html', string='Make Friends by Zipcode')
def boundary_cells(self):
H, W, _ = self.dmap.shape
on_boundary = np.full((H, W), 1.0)
for row in range(H):
for col in range(W):
neighbors = get_neighbors(row, col, H, W, n8=True)
cell_hue = self.dmap[row, col, 0]
for n in neighbors:
neighbor_hue = self.dmap[n[0], n[1], 0]
if self.hue_cmp(cell_hue, neighbor_hue) == 1:
on_boundary[row, col] = 0.0
on_boundary[n[0], n[1]] = 0.0
return on_boundary
def DFS_algorithm(self):
not_visited_nodes = [self.root]
while not_visited_nodes:
if self.max_nodes < len(not_visited_nodes):
self.max_nodes = len(not_visited_nodes)
current_node = not_visited_nodes.pop()
if np.array_equal(np.array(current_node.get_board()),
np.array(self.sorted_matrix)):
#print("Tabuleiro final")
#print(current_node.get_board())
#print('Completou puzzle')
self.solution_path = self.get_solution(current_node)
self.memory_usage = self.determine_memory_usage(
not_visited_nodes)
#print("Movimentos para completar: " + str(self.solution_path))
return
else:
if current_node.get_depth() <= 31:
#Pega todos os visinhos possiveis
neighbors = utils.get_neighbors(current_node.get_board(),
self.board_size)
#laço para percorrer os possiveis vizinhos e adicionar na lista de nao visitados
for neighbor in neighbors:
if current_node.get_value() == -1:
new_board = utils.swap_position(
copy.copy(current_node.get_board()), neighbor)
new_node = node.Node(
current_node,
current_node.get_board()[neighbor[0],
neighbor[1]],
current_node.get_depth() + 1)
new_node.set_board(new_board)
not_visited_nodes.append(new_node)
elif current_node.get_value(
) != current_node.get_board()[neighbor[0],
neighbor[1]]:
#print ("value 1 " + str(current_node.get_value()) + " Value 2 " + str(current_node.get_board()[neighbor[0],neighbor[1]]))
new_board = utils.swap_position(
copy.copy(current_node.get_board()), neighbor)
new_node = node.Node(
current_node,
current_node.get_board()[neighbor[0],
neighbor[1]],
current_node.get_depth() + 1)
new_node.set_board(new_board)
not_visited_nodes.append(new_node)
def _run_cycle(self):
new_active_points = set()
active_neighbor_count = collections.defaultdict(int)
for point in self.active_points:
for neighbor in utils.get_neighbors(point, include_diagonals=True):
active_neighbor_count[neighbor] += 1
for point, active_neighbors in active_neighbor_count.items():
if point in self.active_points and active_neighbors in [2, 3]:
new_active_points.add(point)
elif point not in self.active_points and active_neighbors == 3:
new_active_points.add(point)
self.active_points = new_active_points
def bft(starting_room, exce):
visited = set()
q = Queue()
q.enqueue([starting_room])
paths = []
while q.size() > 0:
path = q.dequeue()
current = path[-1]
paths.append(path)
possible_paths = utils.get_neighbors(current)
for direction, room in possible_paths.items():
if room not in path and room != exce:
new_path = path + [room]
q.enqueue(new_path)
paths.sort(key=len)
return len(paths[-1])
def maximise_own(self, board, p1_c, AI_c, turn):
## This is now considering when it is AI's first turn
## where we intend to place beside player's seed
## (Note: colour is player's colour, not AI's colour)
if turn == 2:
width, height = len(board), len(board[0])
try:
index = [[i, j] for i in range(width) for j in range(height)
if board[i][j] == p1_c][0]
except:
index = [[i, j] for i in range(width) for j in range(height)
if board[i][j] == 3 - p1_c][0]
# If row index > column index i.e. bottom left triangle,
# then place on top of opponent seed. Vice versa
if index[0] > index[1]:
return [index[0] - 1, index[1]]
else:
# else case includes when both indices are equal
return [index[0] + 1, index[1]]
## This is where we consider connecting as many consecutive seeds
## as possible
else:
score = {}
width, height = len(board), len(board[0])
for row in range(width):
for col in range(height):
if board[row][col] == empty:
try: # where we place our seed
score.update(
self.check_surroundings(board, AI_c, row, col))
except IndexError:
pass
##print("Scores: ",score)
v = list(score.values())
k = list(score.keys())
m = max(v)
indices = [i for i, j in enumerate(v) if j == m]
best_score = []
for each in indices:
if k[each][0] >= 0 and k[each][1] >= 0:
best_score.append(k[each])
##print("Best Placements: ",best_score)
for pair in best_score:
res = utils.get_neighbors(pair, board)
if sum([sum(lis) for lis in res]) > 0:
return pair
def refine_boundaries(self, db_map):
H, W, _ = self.dmap.shape
for row in range(H):
for col in range(W):
cell_hue = self.dmap[row, col, 0]
db = db_map[row, col]
other_hue = self.dmap[db[0], db[1], 0]
if self.hue_cmp(cell_hue, other_hue) != 0:
continue
neighbors = get_neighbors(db[0], db[1], H, W, n8=True)
for n in neighbors:
n_hue = self.dmap[n[0], n[1], 0]
if self.hue_cmp(cell_hue, n_hue) != 1:
continue
db_map[row, col] = n
break
def __create_village(self):
"""
Create randomly shaped, randomly placed village in a map.
Private method.
"""
# find suitable random start point for village
start_x = random.randint(0, self.GRID_X-1)
start_y = random.randint(0, self.GRID_Y-1)
if self.map[start_x][start_y]["river"]:
self.__create_village()
return
while self.map[start_x][start_y]["castle"]:
self.__create_village()
return
# generate points of village
village_points = []
for i in range(self.VILLAGE_SIZE):
if i == 0:
village_points.append((start_x, start_y))
else:
# get neighbors of current points and pick random suitable
neighbors = utils.get_neighbors(village_points,
(self.GRID_X, self.GRID_Y))
point = neighbors[random.randint(0, len(neighbors)-1)]
while self.map[point[0]][point[1]]["river"]:
point = neighbors[random.randint(0, len(neighbors)-1)]
neighbors.remove(point)
while self.map[point[0]][point[1]]["castle"]:
point = neighbors[random.randint(0, len(neighbors)-1)]
neighbors.remove(point)
village_points.append(point)
# put village points on map
for point in village_points:
self.map[point[0]][point[1]]["village"] = True
def make_threats(old_board, root_node, parent_node, depth):
### Calling this func takes in a root node and initial board,
### loops through each square, place stone on square and check
### for any threats made. If a single threat is found, then
### update modified_board with the cost squares. Add that board
### to new_boards list. As long as winning sol is not found and
### there are some new boards, recursively call make_threats()
### until a sol is found or no more possible threats can be
### sequenced up.
nonlocal found_sol
nonlocal sol_seq
if depth < 3:
new_boards = []
width, height = len(old_board), len(old_board[0])
score_matrix1 = utils.my_score_matrix(old_board)
score_matrix2 = utils.opponent_score_matrix(old_board)
score_lis = []
for i in range(width):
for j in range(height):
max_ = max(score_matrix1[i][j], score_matrix2[i][j])
min_ = min(score_matrix1[i][j], score_matrix2[i][j])
score_lis.append((max_, min_, (i, j)))
'''
num = score_matrix1[i][j] + score_matrix2[i][j]
score_lis.append( ( num, (i, j) ) )
'''
score_lis.sort(reverse=True)
#count = 10
#score_lis = score_lis[:count]
#res_lis = [ pair[1] for pair in score_lis ]
count = 0
res_lis = []
for i in range(len(score_lis)):
if count == 6: # change
break
_, _, location = score_lis[i]
res = utils.get_neighbors(location, old_board)
#if sum([ sum(lis) for lis in res ]) > 0: # not so empty
res_lis.append(location[:])
count += 1
#res_lis.sort()
shuffle(res_lis)
'''
res_lis = []
for i in range(len(score_lis)):
_, _, location = score_lis[i]
m, n = location
res = utils.get_neighbors(location, old_board)
if sum([ sum(lis) for lis in res ]) > 0: # not so empty
res_lis.append(score_lis[i][2][:])
'''
for pair in res_lis:
i, j = pair
modified_board = deepcopy(old_board)
modified_board[i][j] = AI_c
bool_l = 0
bool_ll = 0
a = loop_board(size, 5, AI_c, modified_board, 0)
b = loop_board(size, 6, AI_c, modified_board, 0)
c = loop_board(size, 7, AI_c, modified_board, 0)
merged_threat_list = a + b + c
if len(merged_threat_list) == 1:
#print("Position: ",i,j)
#print("Threat List: ", merged_threat_list)
x = self.node([i, j])
x.set_parent(parent_node)
parent_node.set_child(x)
for each in merged_threat_list[0]:
modified_board[each[0]][each[1]] = p1_c
new_boards.append([modified_board, x])
elif len(merged_threat_list) == 2:
# a secondary confirmation as a double
# threat may have been found but in fact
# the cost square of one interferes with the
# solution of the other
confirmed = False
confirmed2 = False
for t in merged_threat_list[0]:
sol_board = modified_board.copy()
sol_board[t[0]][t[1]] = p1_c
for p in merged_threat_list[1]:
if not confirmed:
if sol_board[p[0]][p[1]] == empty:
sol_board1 = sol_board.copy()
sol_board1[p[0]][p[1]] = AI_c
if loop_board(size, 5, AI_c, sol_board1,
1) or loop_board(
size, 6, AI_c,
sol_board1, 1):
confirmed = True
if confirmed:
for t in merged_threat_list[
1]: # assuming double-threat only
sol_board = modified_board.copy()
sol_board[t[0]][t[1]] = p1_c
for p in merged_threat_list[0]:
if not confirmed2:
if sol_board[p[0]][p[1]] == empty:
sol_board1 = sol_board.copy()
sol_board1[p[0]][p[1]] = AI_c
if loop_board(
size, 5, AI_c, sol_board1,
1) or loop_board(
size, 6, AI_c, sol_board1,
1):
confirmed2 = True
if confirmed and confirmed2:
#print(merged_threat_list)
#print('found a sol!')
x = self.node([i, j])
x.set_parent(parent_node)
parent_node.set_child(x)
root_node.set_sol(merged_threat_list)
sol_seq = []
store_seq(x)
found_sol = True
##for each in merged_threat_list:
## y = self.node(each)
## y.set_parent(x)
## x.set_child(y)
if len(new_boards) != 0 and found_sol == False:
for each in new_boards:
#print('test')
make_threats(each[0], root_node, each[1], depth + 1)
def shuffle_algorithm(self, n_moves):
self.reset_shuffle_algorithm()
for n in range(n_moves):
self.moves_list.append(
self.swap_positions(utils.get_neighbors(
self.matrix, self.nmax)))
pathlens = []
for j in range(100):
# todo: throw this all into a function.
pos = np.array(start)
maxit = 10000
path = []
actions = []
path.append( pos )
completed = False
for k in range(maxit):
action = utils.select_action(transition[pos[0],pos[1],:])
pos = utils.get_neighbors(pos,level)[action]
path.append( pos )
actions.append( action )
if all( pos==finish ):
completed = True
break
#
#_ = input()
#
path = np.array(path)
rv = utils.reward(path, completed, maxit)
transition = utils.update_transitions(transition, path, actions, rv)
x0 = 2
y0 = 12
map_width = 15
map_height = 15
my_map = utils.generate_map(map_width, map_height)
utils.add_obstacle(my_map, 6, 5, 3, 4)
utils.print_map(my_map)
start_location = utils.Location()
start_location.x = x0
start_location.y = y0
locations = [start_location]
weight = 1
while len(locations) > 0:
nextLocations = []
for location in locations:
utils.set_weight(my_map, location, weight)
nextLocations += utils.get_neighbors(my_map, location)
utils.print_map(my_map)
locations = utils.get_zero_weight_unique_locations(my_map, nextLocations)
weight += 1
input("Press Enter to continue ...\n")
print()
utils.print_map(my_map)
def get_features(dataset,k,n_exs,n_test,b,mode,N_SAMPLES,Neigh_SAMPLE=0, Neigh_PROB=0):
if not os.path.exists("./logs"):
os.makedirs("./logs")
log = open("./logs/log-"+dataset+"-features.out","w",0)
opt = "train"
x_file = "./"+dataset+"/"+opt+"_x.txt"
graph_file = "./"+dataset+"/graph_1.txt"
node_type_file = "./"+dataset+"/node_type.txt"
#build graph
G = build_graph(graph_file, node_type_file)
if dataset == "DBLP":
to_remove = []
for n in G.nodes():
if nx.get_node_attributes(G,'type')[n] == 4:
to_remove.append(n)
G.remove_nodes_from(to_remove)
H = build_bliss_graph(G)
#load x
X = np.loadtxt(x_file)
#gather all patterns in data
patterns = {}
patterns[0] = {}
ex_index = 0
for x in X:
#print(ex_index)
x = map(int,x)
neighbors = get_neighbors(G,x, Neigh_SAMPLE, Neigh_PROB)
if len(neighbors) > N_SAMPLES and N_SAMPLES > 0:
n_hash = []
xl = list(x)
for n in neighbors:
xl.append(n)
xl = map(int, xl)
n_hash.append(graph_hash(bliss_subgraph(H,xl)))
xl.pop()
prob = 1/float(len(set(n_hash)))
counter=collections.Counter(n_hash)
for h in range(0,len(n_hash)):
n_hash[h] = prob*(1/float(counter[n_hash[h]]))
neighbors = np.random.choice(neighbors,N_SAMPLES,replace=False,p=n_hash)
for n in neighbors:
xl = list(x)
xl.append(n)
xl = map(int, xl)
#print xl
gh = graph_hash(bliss_subgraph(H,xl))
conn = 1
if gh not in patterns[0]:
patterns[0][gh] = []
patterns[0][gh].append(ex_index)
else:
patterns[0][gh].append(ex_index)
if gh not in patterns:
g = nx.Graph(G.subgraph(xl))
if nx.is_connected(g):
#print g.nodes(data=True)
#print g.edges()
patterns[gh] = {}
else:
conn = 0
if conn == 1:
#print >>log, datetime.now() - startTime
second_neighbors = get_neighbors(G,xl,Neigh_SAMPLE, Neigh_PROB)
# second_neighbors = G[n]
# second_neighbors = list((set(neighbors) | set(second_neighbors)) - set(xl))
for sn in second_neighbors:
to_del = list(xl)
for d in to_del:
input_pattern = list(xl)
input_pattern.remove(d)
input_pattern.append(int(sn))
ghi = graph_hash(bliss_subgraph(H,input_pattern))
if ghi not in patterns[gh] and ghi not in patterns:
#if nx.is_connected(nx.Graph(G.subgraph(input_pattern))):
patterns[gh][ghi] = []
patterns[gh][ghi].append(ex_index)
elif ghi not in patterns[gh] and ghi in patterns:
patterns[gh][ghi] = []
patterns[gh][ghi].append(ex_index)
else:
patterns[gh][ghi].append(ex_index)
#print >>log, datetime.now() - startTime
xl.pop()
#print datetime.now() - startTime
ex_index = ex_index + 1
if ex_index == n_exs:
break
print >>log, datetime.now() - startTime
print >>log, ex_index/float(n_exs)
opt = "test"
x_file = "./"+dataset+"/"+opt+"_x.txt"
graph_file = "./"+dataset+"/graph_2.txt"
node_type_file = "./"+dataset+"/node_type.txt"
#build graph
G = build_graph(graph_file, node_type_file)
if dataset == "DBLP":
to_remove = []
for n in G.nodes():
if nx.get_node_attributes(G,'type')[n] == 4:
to_remove.append(n)
G.remove_nodes_from(to_remove)
H = build_bliss_graph(G)
#load x
X = np.loadtxt(x_file)
#test_IDS = range(0,len(X[:,]))
test_IDS = False
print >>log, "CONSTRUCTING TEST FEATURES"
ex_index = 0
for x in X:
#print(ex_index + n_exs)
x = x.tolist()
x = map(int,x)
neighbors = get_neighbors(G,x,Neigh_SAMPLE, Neigh_PROB)
if len(neighbors) > N_SAMPLES and N_SAMPLES > 0:
n_hash = []
xl = list(x)
for n in neighbors:
xl.append(n)
xl = map(int, xl)
n_hash.append(graph_hash(bliss_subgraph(H,xl)))
xl.pop()
prob = 1/float(len(set(n_hash)))
counter=collections.Counter(n_hash)
for h in range(0,len(n_hash)):
n_hash[h] = prob*(1/float(counter[n_hash[h]]))
neighbors = np.random.choice(neighbors,N_SAMPLES,replace=False,p=n_hash,)
for n in neighbors:
xl = list(x)
xl.append(n)
xl = map(int, xl)
gh = graph_hash(bliss_subgraph(H,xl))
if gh in patterns[0]:
patterns[0][gh].append(ex_index + n_exs)
if gh in patterns:
#print >>log, datetime.now() - startTime
second_neighbors = get_neighbors(G,xl,Neigh_SAMPLE, Neigh_PROB)
# second_neighbors = G[n]
# second_neighbors = list((set(neighbors) | set(second_neighbors)) - set(xl))
for sn in second_neighbors:
to_del = list(xl)
for d in to_del:
input_pattern = list(xl)
#print input_pattern
input_pattern.remove(d)
input_pattern.append(int(sn))
ghi = graph_hash(bliss_subgraph(H,input_pattern))
if ghi in patterns[gh]:
patterns[gh][ghi].append(ex_index + n_exs)
#print >>log, datetime.now() - startTime
xl.pop()
print >>log, datetime.now() - startTime
ex_index = ex_index + 1
if ex_index == n_test:
break
print >>log, datetime.now() - startTime
num_dim = 0
print >>log, len(patterns)
PL = []
for p in patterns:
num_dim = num_dim + len(patterns[p])
PL.append(len(patterns[p]))
print >>log, PL
print >>log, num_dim
new_X = np.zeros((n_exs + n_test, num_dim))
norm = np.zeros((n_exs + n_test, len(PL)))
j = 0
k = 0
for p in patterns:
for pp in patterns[p]:
for i in patterns[p][pp]:
new_X[i,j] = new_X[i,j] + 1
norm[i,k] = norm[i,k] + 1
j = j + 1
k = k + 1
s = 0
f = 0
pi = 0
for p in PL:
f = s + p
if mode == 'avg':
new_X[:,s:f] = new_X[:,s:f]/(np.transpose(np.tile(norm[:,pi],(p,1))))
s = f
pi = pi + 1
new_X = np.nan_to_num(new_X)
np.savetxt(dataset+'train_x.txt',new_X[0:n_exs,:], '%5.0f')
np.savetxt(dataset+'test_x.txt',new_X[n_exs:(n_exs+n_test),:], '%5.0f')
np.savetxt(dataset+'PL.txt',np.asarray(PL), '%5.0f')
np.savetxt(dataset+'test_IDS.txt',np.atleast_1d(test_IDS), '%5.0f')
return new_X[0:n_exs,:].astype(float), new_X[n_exs:(n_exs+n_test),:].astype(float),PL,test_IDS
