def graph_sketching(args):
with open('json/iot_june_01_10sec.json') as jsonfile:
graphs = json.load(jsonfile)
print("[ ", len(graphs), " ] graphs read successfully")
g = GraphUtils()
g.create_gbad_file(graphs)
def find_clique_aux(self, father, clique):
adjacent = self.graph.get_node(father).neighbors_indices.copy()
while len(adjacent) != 0:
candidate = self.find_better(adjacent)
if GraphUtils.become_clique(self.graph, clique, candidate):
adjacent = GraphUtils.discard_adjacent(self.graph, adjacent,
candidate)
clique.append(candidate)
else:
adjacent.remove(candidate)
def find_clique_aux(self, graph, father, old_clique):
clique = old_clique.copy()
adjacent = graph.get_node(father).neighbors_indices.copy()
while len(adjacent) != 0:
candidate = self.find_better(graph, adjacent)
if GraphUtils.become_clique(graph, clique, candidate):
adjacent = GraphUtils.discard_adjacent(graph, adjacent, candidate)
clique.update({candidate})
else:
adjacent.discard(candidate)
return clique, GraphUtils.calculate_clique_ratio(graph, clique)
def test_read_file_ok(self):
graph = Instance()
graph.read_file(NodeTest.GRAPH_1_TEST_PTH)
self.assertEqual(100, graph.get_total_nodes())
self.assertEqual(2266, graph.get_total_edges())
self.assertEqual(100, len(graph.get_nodes()), 100)
self.assertTrue(GraphUtils.are_adjacent(graph.get_node(0), graph.get_node(1)))
def give_solution(self, ls_solutions, graph):
sort_by_cardinality = sorted(ls_solutions, key=lambda x: x[0], reverse=True)
max_ratio = sort_by_cardinality[0][0]
ls_tuple_max_cardinality = [(x, y, z) for (x, y, z) in sort_by_cardinality if x == max_ratio]
sorted_by_ratio = sorted(ls_tuple_max_cardinality, key=lambda x: x[1], reverse=True)
if not GraphUtils.is_clique_solution(graph, sorted_by_ratio[0][2]):
print('a')
return sorted_by_ratio[0][2]
def test_verify_clique(self):
SET_D = "test_files/setsPruebasFinal/set-d/wind-2004.txt"
SET_F = "test_files/setsPruebasFinal/set-f/DIMACS10/email.txt"
clique = {94, 66, 278, 14}
graph = Instance()
file = SET_D
graph.read_file(file)
if GraphUtils.is_clique_solution(graph, clique):
print("yes")
else:
print("no")
def find_clique(self, vertex):
clique = [vertex]
start_time = time.time()
self.find_clique_aux(vertex, clique)
finish_time = time.time()
self.clique = clique
self.cardinality = len(self.clique)
self.sol_value = GraphUtils.calculate_clique_ratio(
self.graph, self.clique)
self.compute_time = finish_time - start_time
return clique
def apply_ls(self, graph, solution):
sol_copy = solution.copy()
ratio_neighbors = set()
for node in solution:
ratio_neighbors.update(graph.nodes[node].neighbors_indices)
o_ratio_neighbors = sorted(ratio_neighbors, key=lambda x: graph.nodes[x].p_weight / graph.nodes[x].q_weight,
reverse=True)
new_sol_temp = sol_copy.copy()
ls_solutions = list()
for node_ratio in o_ratio_neighbors:
new_sol_temp.update({node_ratio})
if not GraphUtils.is_clique_solution(graph, new_sol_temp):
new_sol_temp = self.clean_conflicted_nodes(graph, node_ratio, new_sol_temp)
if GraphUtils.is_clique_solution(graph, new_sol_temp):
for node_clique in new_sol_temp:
result, result_ratio = self.find_clique_aux(graph, node_clique, new_sol_temp)
if GraphUtils.is_clique_solution(graph, result):
ls_solutions.append((len(result), result_ratio, result))
else:
new_sol_temp.discard(node_ratio)
return self.give_solution(ls_solutions, graph)
def find_grasp_solution(self, graph, name, solution_type, fixed_seed, alpha):
""" Find solution on graph with a GRASP algorithm. """
random.seed(fixed_seed)
total_keys = sorted(list(graph.nodes.keys()))
vertex = random.randint(total_keys[0], total_keys[-1])
solution = {vertex}
cl = graph.nodes[vertex].neighbors_indices.copy()
while len(cl) != 0:
g_min, g_max, gc = self.get_g(cl, solution_type, graph, name)
mu = g_max - alpha * (g_max - g_min)
rcl = self.get_rcl(mu, gc)
random.seed(fixed_seed)
random_position = random.randint(0, len(rcl) - 1)
u = rcl[random_position][0]
if GraphUtils.become_clique(graph, solution, u):
solution = solution.union({u})
cl -= {u}
cl.intersection_update(graph.get_node(u).neighbors_indices)
return solution
def handler(event, context):
source_bucket = event['Records'][0]['s3']['bucket']['name']
key = event['Records'][0]['s3']['object']['key']
try:
waiter = s3.get_waiter('object_exists')
waiter.wait(Bucket=source_bucket, Key=key)
bucket = tests3.Bucket(u'data-testlambdas3')
obj = bucket.Object(key='data.json')
response = obj.get()
items = json.loads(response['Body'].read().decode("utf-8"))
print(json.dumps(items, indent=2, sort_keys=False))
for item_dict in items:
data = GraphUtils.create_graph(item_dict)
write_to_db(data)
except Exception as e:
print('Unhandled exception => %s' % str(e))
print('Error getting object {} from bucket {}. '
'Make sure they exist and your bucket is in the same region as this function.'
.format(key, source_bucket))
for file in glob.glob(GRAPH_PATH_SETS + ALL_FILES_TXT_EXT, recursive=True):
for solution_type in solution_types:
data = dict()
data_ls = dict()
filename = os.path.splitext(os.path.basename(file))[0]
graph.read_file(file)
instance_solution = SolutionGrasp()
for alpha in alpha_list:
for iteration in range(1, TOTAL_ITERATIONS + 1):
start_time = time.time()
signal.alarm(TIMEOUT_VALUE)
try:
solution = instance_solution.find_grasp_solution(
graph, file, solution_type, fixed_seed, alpha)
find_grasp_sol_time = time.time() - start_time
ratio, density, cardinality = GraphUtils.calculate_solution(
graph, solution)
local_search_sol = instance_solution.apply_ls(
graph, solution)
find_ls_sol_time = time.time() - start_time
ls_ratio, ls_density, ls_cardinality = GraphUtils.calculate_solution(
graph, local_search_sol)
table_key_name = filename + MAIN_SEP_NAMES + solution_type + MAIN_SEP_NAMES + str(
iteration) + MAIN_SEP_NAMES + str(alpha)
data.update({
table_key_name: [
graph.get_total_nodes(), density, ratio,
cardinality, find_grasp_sol_time, alpha
]
})
def shingle_sketch(self, graphs, args):
score = {}
param_w = args.win_size
graph_ids = [id for id in graphs]
random.shuffle(graph_ids)
# print("Total Graph:", graph_ids)
total_chunk = math.ceil(len(graph_ids) / args.win_size)
print("Total Chunk: ", total_chunk)
chunk_index = [i * args.win_size for i in range(0, total_chunk)]
#add last index
graph_shingles = {}
chunk_index.append(len(graph_ids) - 1)
print("Chunk Index: ", chunk_index)
index = 0
for chunks in range(0, total_chunk):
disc_shingles = []
sketch_list = []
print("\nChunk: ", chunks)
print("\n\nGenerating Disc Shingles....")
for g in tqdm(range(chunk_index[chunks], chunk_index[chunks + 1])):
# print("Graph : ", graph_ids[g])
index += 1
# nx_G = graphs[graph_ids[g]]['graph']
gu = GraphUtils()
nx_G = gu.create_graph(graphs[graph_ids[g]])
walk_len = args.walk_len #len(nx_G.edges()) #args.walk_len
# G = node2vec.Graph(nx_G, args.directed, p=1, q=1)
# G.preprocess_transition_probs()
# walk_path = G.simulate_walks(args.num_walks, walk_len)
#
prob = self.preprocess_transition_probs(nx_G)
# print("Prob: ", prob)
walk_path = self.simulate_random_walks(nx_G, walk_len, prob)
# print("\n\n Graph: ", graph_ids[g], " Walk: ", walk_path)
shingles = self.generate_shingles(walk_path, args.k_shingle)
sorted_sh = sorted(shingles.items(), key=lambda kv: kv[1])
# print("\n\n Graph: ", graph_ids[g], " Shingles: ", sorted_sh)
graph_shingles[int(graph_ids[g])] = shingles
# graph_utils.draw_graph(graph, g)
self.update_one_step_forward_window(shingles, index, param_w)
# disc_shingles = self.get_disc_shingle_using_entropy(args)
disc_shingles = self.get_disc_shingles(args.sketch_size)
# print("Disc Shingles: ", disc_shingles)
# print("\n\nGenerating Sketch....")
for g in tqdm(range(chunk_index[chunks], chunk_index[chunks + 1])):
shingles = graph_shingles[int(graph_ids[g])]
sketch_vec = self.get_graph_sketch(shingles, disc_shingles)
sketch_list.append([
graph_ids[g], sketch_vec, graphs[graph_ids[g]]['label'],
graphs[graph_ids[g]]['anom_count']
])
# print("\n\n Graph: ", graph_ids[g], " Sketch: ", sketch_vec)
# print("Final Sketch: ", sketch_list)
sketch_vecs = pd.DataFrame(
sketch_list,
columns=['graphid', 'sketch', 'anomaly', 'anom_count'])
sketch_vecs.to_csv('batch/' + str(chunks) + ".csv")
# classification
ad = AnomalyDetection()
rf_acc, dt_acc, svm_acc = ad.anomaly_detection(sketch_vecs, args)
score[chunks] = {"rf": rf_acc, "dt": dt_acc, "svm": svm_acc}
print(score)
def train(args):
model_path = os.path.join('../', args.model_name)
if os.path.exists(model_path) is False:
os.makedirs(model_path)
alpha, beta, gamma, lam = args.alpha, args.beta, args.gamma, args.lam
print('======== experiment settings =========')
print(
'alpha : %0.4f, beta : %0.4f, gamma : %0.4f, lam : %0.4f, p : %0.4f, ws : %d, ns : %d, maxT : % d, minT : %d, max_iter : %d, d : %d'
% (alpha, beta, gamma, lam, args.p, args.ws, args.ns, args.maxT,
args.minT, args.max_iter, args.d))
print('========== processing data ===========')
dul = DataUtils(model_path)
if args.rec:
test_user, test_item, test_rate = dul.read_data(args.test_data)
print("constructing graph....")
gul = GraphUtils(model_path)
gul.construct_training_graph(args.train_data)
edge_dict_u = gul.edge_dict_u
edge_list = gul.edge_list
walk_generator(gul, args)
print("getting context and negative samples....")
context_dict_u, neg_dict_u, context_dict_v, neg_dict_v, node_u, node_v = get_context_and_negative_samples(
gul, args)
node_list_u, node_list_v = {}, {}
init_embedding_vectors(node_u, node_v, node_list_u, node_list_v, args)
last_loss, count, epsilon = 0, 0, 1e-3
print("============== training ==============")
for iter in range(0, args.max_iter):
s1 = "\r[%s%s]%0.2f%%" % ("*" * iter, " " *
(args.max_iter - iter), iter * 100.0 /
(args.max_iter - 1))
loss = 0
num = 0
visited_u = dict(zip(node_list_u.keys(),
[0] * len(node_list_u.keys())))
visited_v = dict(zip(node_list_v.keys(),
[0] * len(node_list_v.keys())))
random.shuffle(edge_list)
for (u, v, w) in edge_list:
if visited_u.get(u) == 0 or random.random() > 0.95:
# print(u)
length = len(context_dict_u[u])
index_list = random.sample(list(range(length)), min(length, 1))
for index in index_list:
context_u = context_dict_u[u][index]
neg_u = neg_dict_u[u][index]
# center,context,neg,node_list,eta
for k, z in enumerate(context_u):
tmp_z, tmp_loss = skip_gram(u, z, neg_u, node_list_u,
lam, alpha)
node_list_u[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_u[u] = 1
if visited_v.get(v) == 0 or random.random() > 0.95:
# print(v)
length = len(context_dict_v[v])
index_list = random.sample(list(range(length)), min(length, 1))
for index in index_list:
context_v = context_dict_v[v][index]
neg_v = neg_dict_v[v][index]
# center,context,neg,node_list,eta
for k, z in enumerate(context_v):
tmp_z, tmp_loss = skip_gram(v, z, neg_v, node_list_v,
lam, beta)
node_list_v[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_v[v] = 1
# print(len(edge_dict_u))
update_u, update_v, tmp_loss = KL_divergence(
edge_dict_u, u, v, node_list_u, node_list_v, lam, gamma)
loss += tmp_loss
node_list_u[u]['embedding_vectors'] += update_u
node_list_v[v]['embedding_vectors'] += update_v
count = iter
num += 1
delta_loss = abs(loss - last_loss)
if last_loss > loss:
lam *= 1.05
else:
lam *= 0.95
last_loss = loss
if delta_loss < epsilon:
break
sys.stdout.write(s1)
sys.stdout.flush()
save_to_file(node_list_u, node_list_v, model_path, args)
print("")
if args.rec:
print("============== testing ===============")
f1, map, mrr, mndcg = top_N(test_user, test_item, test_rate,
node_list_u, node_list_v, args.top_n)
print(
'recommendation metrics: F1 : %0.4f, MAP : %0.4f, MRR : %0.4f, NDCG : %0.4f'
% (round(f1, 4), round(map, 4), round(mrr, 4), round(mndcg, 4)))
if args.lip:
print("============== testing ===============")
auc_roc, auc_pr = link_prediction(args)
print('link prediction metrics: AUC_ROC : %0.4f, AUC_PR : %0.4f' %
(round(auc_roc, 4), round(auc_pr, 4)))
def train():
alpha, beta, gamma, lam = args.alpha, args.beta, args.gamma, args.lam
print('======== experiment settings =========')
print('alpha : %0.4f, beta : %0.4f, gamma : %0.4f, lam : %0.4f, p : %0.4f, ws : %d, ns : %d, maxT : % d, minT : %d, max_iter : %d, d : %d' % (alpha, beta, gamma, lam, args.p, args.ws, args.ns,args.maxT,args.minT,args.max_iter, args.d))
print('========== processing data ===========')
dul = DataUtils(model_path)
if args.rec:
test_user, test_item, test_rate = dul.read_data(args.test_data)
print("constructing graph....")
gul = GraphUtils(model_path)
gul.construct_training_graph(args.train_data)
edge_dict_u = gul.edge_dict_u
edge_list = gul.edge_list
walk_generator(gul,args)
print("getting context and negative samples....")
context_dict_u, neg_dict_u, context_dict_v, neg_dict_v, node_u, node_v = get_context_and_negative_samples(gul, args)
node_list_u, node_list_v = {}, {}
init_embedding_vectors(node_u, node_v, node_list_u, node_list_v, args)
last_loss, count, epsilon = 0, 0, 1e-3
print("============== training ==============")
for iter in range(0, args.max_iter):
s1 = "\r[%s%s]%0.2f%%"%("*"* iter," "*(args.max_iter-iter),iter*100.0/(args.max_iter-1))
loss = 0
visited_u = dict(zip(node_list_u.keys(), [0] * len(node_list_u.keys())))
visited_v = dict(zip(node_list_v.keys(), [0] * len(node_list_v.keys())))
random.shuffle(edge_list)
for i in range(len(edge_list)):
u, v, w = edge_list[i]
length = len(context_dict_u[u])
random.shuffle(context_dict_u[u])
if visited_u.get(u) < length:
# print(u)
index_list = list(range(visited_u.get(u),min(visited_u.get(u)+1,length)))
for index in index_list:
context_u = context_dict_u[u][index]
neg_u = neg_dict_u[u][index]
# center,context,neg,node_list,eta
for z in context_u:
tmp_z, tmp_loss = skip_gram(u, z, neg_u, node_list_u, lam, alpha)
node_list_u[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_u[u] = index_list[-1]+3
length = len(context_dict_v[v])
random.shuffle(context_dict_v[v])
if visited_v.get(v) < length:
# print(v)
index_list = list(range(visited_v.get(v),min(visited_v.get(v)+1,length)))
for index in index_list:
context_v = context_dict_v[v][index]
neg_v = neg_dict_v[v][index]
# center,context,neg,node_list,eta
for z in context_v:
tmp_z, tmp_loss = skip_gram(v, z, neg_v, node_list_v, lam, beta)
node_list_v[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_v[v] = index_list[-1]+3
update_u, update_v, tmp_loss = KL_divergence(edge_dict_u, u, v, node_list_u, node_list_v, lam, gamma)
loss += tmp_loss
node_list_u[u]['embedding_vectors'] += update_u
node_list_v[v]['embedding_vectors'] += update_v
delta_loss = abs(loss - last_loss)
if last_loss > loss:
lam *= 1.05
else:
lam *= 0.95
last_loss = loss
if delta_loss < epsilon:
break
sys.stdout.write(s1)
sys.stdout.flush()
def train_by_sampling(args):
model_path = os.path.join('../', args.model_name)
if os.path.exists(model_path) is False:
os.makedirs(model_path)
alpha, beta, gamma, lam = args.alpha, args.beta, args.gamma, args.lam
print('======== experiment settings =========')
print(
'alpha : %0.4f, beta : %0.4f, gamma : %0.4f, lam : %0.4f, p : %0.4f, ws : %d, ns : %d, maxT : % d, minT : %d, max_iter : %d, d : %d'
% (alpha, beta, gamma, lam, args.p, args.ws, args.ns, args.maxT,
args.minT, args.max_iter, args.d))
print('========== processing data ===========')
dul = DataUtils(model_path)
if args.rec:
test_user, test_item, test_rate = dul.read_data(args.test_data)
print("constructing graph....")
gul = GraphUtils(model_path)
gul.construct_training_graph(
args.train_data) # train_data='../data/wiki/rating_train.dat'
edge_dict_u = gul.edge_dict_u # dict形式的点边关系
edge_list = gul.edge_list # list形式的点边关系
walk_generator(gul, args) # 生成随机游走
print("getting context and negative samples....")
context_dict_u, neg_dict_u, context_dict_v, neg_dict_v, node_u, node_v = get_context_and_negative_samples(
gul, args)
node_list_u, node_list_v = {}, {}
init_embedding_vectors(node_u, node_v, node_list_u, node_list_v,
args) # 初始化节点embedding
last_loss, count, epsilon = 0, 0, 1e-3
print("============== training ==============")
for iter in range(0, args.max_iter):
s1 = "\r[%s%s]%0.2f%%" % ("*" * iter, " " *
(args.max_iter - iter), iter * 100.0 /
(args.max_iter - 1))
loss = 0
visited_u = dict(zip(node_list_u.keys(),
[0] * len(node_list_u.keys()))) # u类别初始为0
visited_v = dict(zip(node_list_v.keys(),
[0] * len(node_list_v.keys()))) # v类别初始为0
random.shuffle(edge_list) # edge_list: 点边信息
for i in range(len(edge_list)):
u, v, w = edge_list[i]
length = len(context_dict_u[u]) # 周围邻居的数量
random.shuffle(context_dict_u[u])
if visited_u.get(u) < length:
# print(u)
index_list = list(
range(visited_u.get(u), min(visited_u.get(u) + 1, length)))
for index in index_list:
context_u = context_dict_u[u][index] # 选择节点的一个邻居
neg_u = neg_dict_u[u][
index] # 选择节点的负采样信息; 负采样本身就是随机的，所以只需打乱context即可，并且多个epoch训练时，负采样样本也不同
# center,context,neg,node_list,eta
for z in context_u: # 每一个邻居节点，都进行skip-gram更新embedding
tmp_z, tmp_loss = skip_gram(u, z, neg_u, node_list_u,
lam, alpha)
node_list_u[u][
'embedding_vectors'] += tmp_z # 更新节点embedding
loss += tmp_loss
visited_u[u] = index_list[-1] + 3
length = len(context_dict_v[v])
random.shuffle(context_dict_v[v])
if visited_v.get(v) < length:
# print(v)
index_list = list(
range(visited_v.get(v), min(visited_v.get(v) + 1, length)))
for index in index_list:
context_v = context_dict_v[v][index]
neg_v = neg_dict_v[v][index]
# center,context,neg,node_list,eta
for z in context_v:
tmp_z, tmp_loss = skip_gram(v, z, neg_v, node_list_v,
lam, beta)
node_list_v[v]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_v[v] = index_list[-1] + 3
# edge_dict_u:边连接的信息
update_u, update_v, tmp_loss = KL_divergence(
edge_dict_u, u, v, node_list_u, node_list_v, lam,
gamma) # 计算KL-deversion
loss += tmp_loss
node_list_u[u]['embedding_vectors'] += update_u
node_list_v[v]['embedding_vectors'] += update_v
# 求的是梯度上升，loss越大越好
delta_loss = abs(loss - last_loss)
if last_loss > loss:
lam *= 1.05
else:
lam *= 0.95
last_loss = loss
if delta_loss < epsilon:
break
sys.stdout.write(s1)
sys.stdout.flush()
save_to_file(node_list_u, node_list_v, model_path, args)
print("")
if args.rec:
print("============== testing ===============")
f1, map, mrr, mndcg = top_N(test_user, test_item, test_rate,
node_list_u, node_list_v, args.top_n)
print(
'recommendation metrics: F1 : %0.4f, MAP : %0.4f, MRR : %0.4f, NDCG : %0.4f'
% (round(f1, 4), round(map, 4), round(mrr, 4), round(mndcg, 4)))
if args.lip:
print("============== testing ===============")
auc_roc, auc_pr = link_prediction(args)
print('link prediction metrics: AUC_ROC : %0.4f, AUC_PR : %0.4f' %
(round(auc_roc, 4), round(auc_pr, 4)))
def main(self):
v = View()
files = ['assets/data/map_data.json', 'assets/data/cmi_hub.json']
g = Graph()
self.build_graph_from_files(g, files)
utils = GraphUtils()
v.print_menu()
while (True):
v.print_prompt_user()
code = raw_input()
if (code == '0' or code == 'exit'):
exit(0)
elif (code == '1'):
#@todo fix this
v.city_info(g)
elif (code == '2'):
longest_flight = utils.longest_flight(g)
v.print_flight(longest_flight)
elif (code == '3'):
shortest_flight = utils.shortest_flight(g)
v.print_flight(shortest_flight)
elif (code == '4'):
map_string = utils.get_map_string(g)
v.display_map(map_string)
elif (code == '5'):
average_flight_distance = utils.average_distance(g)
v.print_average_flight_distance(average_flight_distance)
elif (code == '6'):
largest_population = utils.biggest_city(g)
v.print_population(largest_population)
elif (code == '7'):
smallest_population = utils.smallest_city(g)
v.print_population(smallest_population)
elif (code == '8'):
average_population = utils.average_city(g)
v.print_population_number(average_population)
elif (code == '9'):
continents_dict = utils.get_continents_and_cities(g)
v.print_continents_and_cities(continents_dict)
elif (code == '10'):
hubs = utils.get_hub_cities(g)
v.print_hub_cities(hubs)
elif (code == '11'):
cities = utils.get_cities(g)
v.print_cities(cities)
elif (code == '12'):
# add a city
data = v.add_city_menu()
g.add_node(data)
elif (code == '13'):
data = v.add_route_menu()
g.add_route(data['src'], data['dst'], data['distance'])
# add a route
pass
elif (code == '14'):
# remove a city
code = v.remove_city_menu()
g.remove_node(code)
elif (code == '15'):
# remove a route
data = v.remove_route_menu()
g.remove_route(data['src'], data['dst'])
elif (code == '16'):
# edit a city
data = v.edit_city_menu()
g.edit_node(data)
elif (code == '17'):
# save to disk
utils.save_to_disk(g)
v.print_success()
# @todo prints errors success
elif (code == '18'):
cities = v.route_menu()
route_return = utils.route_info(g, cities)
v.print_route_info(route_return)
elif (code == '19'):
cities = v.route_menu()
route = utils.shortestPath(g, cities[0], cities[1])
v.print_route(route)
route_return = utils.route_info(g, route)
v.print_route_info(route_return)
elif (code == '20'):
v.print_menu()
else:
v.print_error()
def test_obtain_clique_ko(self):
graph = Instance()
graph.read_file(NodeTest.GRAPH_SIMPLE_2_TEST_PTH)
solution = Solution(graph)
self.assertFalse(GraphUtils.is_clique(solution.get_graph()))
class Pipeline:
def __init__(self):
self.graph_utils = GraphUtils()
self.file_utils = FileUtils()
def evaluate_policy(self,
folder_path,
num_evals,
env,
garden_x,
garden_y,
sector_width,
sector_height,
is_baseline=False,
baseline_policy=None,
step=1):
model = None
if not is_baseline:
model = PPO2.load('./' + folder_path + '/model')
done = False
for _ in range(num_evals):
obs = env.reset()
garden_obs = env.env_method('get_garden_state')
e = {
'cell_avg_action': [],
'full_state_action': [],
'full_state': [],
'rewards': [],
'action': []
}
cell_avg_action = {}
for x in range(garden_x):
for y in range(garden_y):
cell_avg_action[x, y] = 0
step_counter = 0
idx = 0
while not done:
print("ITERATION ", idx)
action = None
if is_baseline:
action = baseline_policy(obs,
step,
threshold=0.5,
amount=1,
irr_threshold=0)
else:
action, _states = model.predict(obs)
obs, rewards, done, _ = env.step(action)
idx += 1
action = env.env_method('get_curr_action')
garden_obs = env.env_method('get_garden_state')
radius_grid = env.env_method('get_radius_grid')
# if not done:
# step_counter = env.env_method('get_current_step')[0]
# rg_list = radius_grid[0].tolist()
# obs_action_pairs = []
# sector = env.env_method('get_sector')[0]
# sector_x = get_sector_x(sector, garden_x, sector_width)
# sector_y = get_sector_y(sector, garden_y, sector_height)
# for x in range(garden_x):
# for y in range(garden_y):
# cell = (x, y)
# if cell[0] >= sector_x and cell[0] < sector_x + sector_width and cell[1] >= sector_y and cell[1] < sector_y + sector_height:
# cell_action = env.env_method('get_irr_action')[0]
# else:
# cell_action = 0
# obs_action_pairs.append({str(cell) : (str(rg_list[x][y][0]), str(cell_action))})
# cell_avg_action[cell] += cell_action
# e['full_state_action'].append({step_counter : obs_action_pairs})
# e['full_state'].append(garden_obs[0].tolist())
# e['rewards'].append(rewards.item())
# e['action'].append(action[0].tolist())
# env.render()
done = False
# for x in range(garden_x):
# for y in range(garden_y):
# cell_avg_action[(x, y)] /= step_counter
# e['cell_avg_action'].append({str((x, y)) : cell_avg_action[(x, y)], 'final_radius': rg_list[x][y][0]})
''' UNCOMMENT IF YOU WANT TO WRITE OUTPUTS TO A FILE. WILL TAKE AWHILE FOR LARGE GARDENS. '''
# pathlib.Path(folder_path + '/Returns').mkdir(parents=True, exist_ok=True)
# filename = folder_path + '/Returns' + '/predict_' + str(i) + '.json'
# f = open(filename, 'w')
# f.write(json.dumps(e, indent=4))
# f.close()
def single_run(self,
folder_path,
num_evals,
policy_kwargs=None,
is_baseline=False,
baseline_policy=None):
# initialize cProfile
profiler_object = cProfile.Profile()
profiler_object.enable()
config = configparser.ConfigParser()
config.read('gym_config/config.ini')
rl_time_steps = config.getint('rl', 'time_steps')
ent_coef = config.getfloat('rl', 'ent_coef')
n_steps = config.getint('rl', 'n_steps')
nminibatches = config.getint('rl', 'nminibatches')
noptepochs = config.getint('rl', 'noptepochs')
learning_rate = config.getfloat('rl', 'learning_rate')
time_steps = config.getint('garden', 'time_steps')
step = config.getint('garden', 'step')
num_plants_per_type = config.getint('garden', 'num_plants_per_type')
num_plant_types = config.getint('garden', 'num_plant_types')
garden_x = config.getint('garden', 'X')
garden_y = config.getint('garden', 'Y')
garden_z = 2 * config.getint(
'garden', 'num_plant_types'
) + 1 # Z axis contains a matrix for every plant type plus one for water levels.
sector_width = config.getint('garden', 'sector_width')
sector_height = config.getint('garden', 'sector_height')
action_low = config.getfloat('action', 'low')
action_high = config.getfloat('action', 'high')
obs_low = config.getint('obs', 'low')
obs_high = config.getint('obs', 'high')
env = gym.make(
'simalphagarden-v0',
wrapper_env=SimAlphaGardenWrapper(time_steps,
garden_x,
garden_y,
sector_width,
sector_height,
num_plant_types,
num_plants_per_type,
step=step),
garden_x=garden_x,
garden_y=garden_y,
garden_z=garden_z,
sector_width=sector_width,
sector_height=sector_height,
action_low=action_low,
action_high=action_high,
obs_low=obs_low,
obs_high=obs_high,
)
env = DummyVecEnv([lambda: env])
# TODO: Normalize input features? VecNormalize
env = VecCheckNan(env, raise_exception=False)
if is_baseline:
copyfile('gym_config/config.ini', folder_path + '/config.ini')
# Evaluate baseline on 50 random environments of same parameters.
self.evaluate_policy(folder_path,
num_evals,
env,
garden_x,
garden_y,
sector_width,
sector_height,
is_baseline=True,
baseline_policy=baseline_policy,
step=1)
# Graph evaluations
self.graph_utils.graph_evaluations(folder_path, garden_x, garden_y,
time_steps, step, num_evals,
num_plant_types)
else:
pathlib.Path(folder_path + '/ppo_v2_tensorboard').mkdir(
parents=True, exist_ok=True)
# Instantiate the agent
model = PPO2(CustomCnnPolicy,
env,
policy_kwargs=policy_kwargs,
ent_coef=ent_coef,
n_steps=n_steps,
nminibatches=nminibatches,
noptepochs=noptepochs,
learning_rate=learning_rate,
verbose=1,
tensorboard_log=folder_path + '/ppo_v2_tensorboard/')
# model = PPO2(MlpPolicy, env, ent_coef=ent_coef, n_steps=n_steps, nminibatches=nminibatches, noptepochs=noptepochs, learning_rate=learning_rate, verbose=1, tensorboard_log=folder_path + '/ppo_v2_tensorboard/')
# Train the agent
model.learn(
total_timesteps=rl_time_steps
) # this will crash explaining that the invalid value originated from the env
model.save(folder_path + '/model')
copyfile('gym_config/config.ini', folder_path + '/config.ini')
# Evaluate model on 50 random environments of same parameters.
self.evaluate_policy(folder_path,
num_evals,
env,
garden_x,
garden_y,
sector_width,
sector_height,
is_baseline=False)
# Graph evaluations
# self.graph_utils.graph_evaluations(folder_path, garden_x, garden_y, time_steps, step, num_evals, num_plant_types)
profiler_object.disable()
# dump the profiler stats
s = io.StringIO()
ps = pstats.Stats(profiler_object, stream=s).sort_stats('cumulative')
pathlib.Path(folder_path + '/Timings').mkdir(parents=True,
exist_ok=True)
ps.dump_stats(folder_path + '/Timings/dump.txt')
# convert to human readable format
out_stream = open(folder_path + '/Timings/time.txt', 'w')
ps = pstats.Stats(folder_path + '/Timings/dump.txt', stream=out_stream)
ps.strip_dirs().sort_stats('cumulative').print_stats()
def batch_run(self,
n,
rl_config,
garden_x,
garden_y,
sector_width,
sector_height,
num_plant_types,
num_plants_per_type,
policy_kwargs=[],
num_evals=1,
is_baseline=[],
baseline_policy=None):
assert (len(rl_config) == n)
assert (len(garden_x) == n)
assert (len(garden_y) == n)
assert (len(sector_width) == n)
assert (len(sector_height) == n)
assert (len(num_plant_types) == n)
assert (len(num_plants_per_type) == n)
if is_baseline:
assert (len(is_baseline) == n)
assert (baseline_policy != None)
assert (len(policy_kwargs) == n)
else:
assert (len(policy_kwargs) == 1)
if is_baseline:
for i in range(n):
filename_time = time.strftime('%Y-%m-%d-%H-%M-%S')
if is_baseline[i]:
folder_path = self.file_utils.createBaselineSingleRunFolder(
garden_x[i], garden_y[i], num_plant_types[i],
num_plants_per_type[i], policy_kwargs[i],
filename_time)
self.file_utils.create_config(
rl_time_steps=rl_config[i]['time_steps'],
garden_x=garden_x[i],
garden_y=garden_y[i],
sector_width=sector_width[i],
sector_height=sector_height[i],
num_plant_types=num_plant_types[i],
num_plants_per_type=num_plants_per_type[i],
cnn_args=policy_kwargs[i])
self.single_run(folder_path,
num_evals,
is_baseline=True,
baseline_policy=baseline_policy)
else:
folder_path = self.file_utils.createRLSingleRunFolder(
garden_x[i], garden_y[i], num_plant_types[i],
num_plants_per_type[i], rl_config[i], policy_kwargs[i],
filename_time)
self.file_utils.create_config(
rl_time_steps=rl_config[i]['time_steps'],
garden_x=garden_x[i],
garden_y=garden_y[i],
sector_width=sector_width[i],
sector_height=sector_height[i],
num_plant_types=num_plant_types[i],
num_plants_per_type=num_plants_per_type[i],
ent_coef=rl_config[i]['ent_coef'],
nminibatches=rl_config[i]['nminibatches'],
noptepochs=rl_config[i]['noptepochs'],
learning_rate=rl_config[i]['learning_rate'],
cnn_args=policy_kwargs[i])
self.single_run(folder_path,
num_evals,
policy_kwargs[i],
is_baseline=False)
else:
for i in range(n):
filename_time = time.strftime('%Y-%m-%d-%H-%M-%S')
folder_path = self.file_utils.createRLSingleRunFolder(
garden_x[i], garden_y[i], num_plant_types[i],
num_plants_per_type[i], rl_config[i], policy_kwargs[i],
filename_time)
self.file_utils.create_config(
rl_time_steps=rl_config[i]['time_steps'],
garden_x=garden_x[i],
garden_y=garden_y[i],
sector_width=sector_width[i],
sector_height=sector_height[i],
num_plant_types=num_plant_types[i],
num_plants_per_type=num_plants_per_type[i],
ent_coef=rl_config[i]['ent_coef'],
nminibatches=rl_config[i]['nminibatches'],
noptepochs=rl_config[i]['noptepochs'],
learning_rate=rl_config[i]['learning_rate'],
cnn_args=policy_kwargs[i])
self.single_run(folder_path,
num_evals,
policy_kwargs[0],
is_baseline=False)
def test_create_graph(self):
with open('data.json') as fixture:
dict_list = json.load(fixture)
graph = GraphUtils.create_graph(dict_list[0])
self.assertIn("Monkey", graph)
self.assertEqual(graph['Animal']['children'], ["Monkey"])
def main(self):
v = View()
files = ['assets/data/map_data.json', 'assets/data/cmi_hub.json']
g = Graph()
self.build_graph_from_files(g, files)
utils = GraphUtils()
v.print_menu()
while (True):
v.print_prompt_user()
code = raw_input()
if (code == '0' or code == 'exit'):
exit(0)
elif (code == '1'):
#@todo fix this
v.city_info(g)
elif (code == '2'):
longest_flight = utils.longest_flight(g)
v.print_flight(longest_flight)
elif (code == '3'):
shortest_flight = utils.shortest_flight(g)
v.print_flight(shortest_flight)
elif (code == '4'):
map_string = utils.get_map_string(g)
v.display_map(map_string)
elif (code == '5'):
average_flight_distance = utils.average_distance(g)
v.print_average_flight_distance(average_flight_distance)
elif (code == '6'):
largest_population = utils.biggest_city(g)
v.print_population(largest_population)
elif (code == '7'):
smallest_population = utils.smallest_city(g)
v.print_population(smallest_population)
elif (code == '8'):
average_population = utils.average_city(g)
v.print_population_number(average_population)
elif (code == '9'):
continents_dict = utils.get_continents_and_cities(g)
v.print_continents_and_cities(continents_dict)
elif (code == '10'):
hubs = utils.get_hub_cities(g)
v.print_hub_cities(hubs)
elif (code == '11'):
cities = utils.get_cities(g)
v.print_cities(cities)
elif (code == '12'):
# add a city
data = v.add_city_menu()
g.add_node(data)
elif (code == '13'):
data = v.add_route_menu()
g.add_route(data['src'], data['dst'], data['distance'])
# add a route
pass
elif (code == '14'):
# remove a city
code = v.remove_city_menu()
g.remove_node(code)
elif (code == '15'):
# remove a route
data = v.remove_route_menu()
g.remove_route(data['src'], data['dst'])
elif (code == '16'):
# edit a city
data = v.edit_city_menu()
g.edit_node(data)
elif (code == '17'):
# save to disk
utils.save_to_disk(g)
v.print_success()
# @todo prints errors success
elif (code == '18'):
cities = v.route_menu()
route_return = utils.route_info(g, cities)
v.print_route_info(route_return)
elif (code == '19'):
cities = v.route_menu()
route = utils.shortestPath(g, cities[0], cities[1])
v.print_route(route)
route_return = utils.route_info(g, route)
v.print_route_info(route_return)
elif (code == '20'):
v.print_menu()
else:
v.print_error()
def __init__(self):
self.graph_utils = GraphUtils()
self.file_utils = FileUtils()
