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 __init__(self): self.graph_utils = GraphUtils() self.file_utils = FileUtils()