def __init__(self, user_url): self.user_url = user_url self.user_network = DirectedGraph() self.user = User(user_url) self.user.make_followers() self.user.make_following()
def import_graph(self, file_name, process=lambda progress: None): try: file_graph = open(file_name + ".txt", "r") lines = file_graph.readlines() first_line = lines.pop(0).strip() graph_params = first_line.split() imported_graph = DirectedGraph(int(graph_params[0])) total_lines = len(lines) last_percent = 0 for index, line in enumerate(lines): new_percent = index * 100 // total_lines if last_percent != new_percent: process(new_percent) last_percent = new_percent data = line.strip().split(" ") imported_graph.add_edge(int(data[0]), int(data[1]), int(data[2])) self.graphs.append(imported_graph) file_graph.close() except FileNotFoundError: raise Exception("File '" + file_name + "' not found")
def setUp(self): self.graph = DirectedGraph() self.nodeA = "A" self.nodeB = "B" self.nodeC = "C" self.nodeD = "D" self.nodeE = "E"
def inOutDegree(graph: DirectedGraph): ''' Function that calculate in and out dege ''' vertex = int(input(" vertex : ")) print("OUT degree:", graph.outDegreeOf(vertex)) print("IN degree:", graph.inDegreeOf(vertex), "\n")
def read_graph(filename='graph.txt'): file = open(filename, 'r') # read the first line containing the number of vertices and number of edges line = file.readline() # remove the newline from the end of the string and splitting its parameters line = line.strip('\n') line = line.split(' ') if len(line) != 2: raise ValueError('invalid number of vertices and edges') vertices = int(line[0]) edges = int(line[1]) # create a directed graph with given vertices graph = DirectedGraph(vertices) for i in range(edges): edge = file.readline() edge = edge.strip('\n') edge = edge.split(' ') if len(edge) != 3: raise ValueError('invalid line in file!') start_vertex = int(edge[0]) end_vertex = int(edge[1]) cost = int(edge[2]) graph.add_edge(start_vertex, end_vertex, cost) file.close() return deepcopy(graph)
def test_in_degree_directed(self): graph = DirectedGraph(7) graph.add_edge(0, 1) graph.add_edge(0, 5) self.assertEqual(graph.in_degree(0), 0) self.assertEqual(graph.in_degree(1), 1) self.assertEqual(graph.in_degree(1), 1)
def modifyCost(graph: DirectedGraph): ''' Function that modify the cost of an edge ''' edgeID = int(input(" edge id : ")) newCost = int(input(" new cost : ")) graph.modifyCostOf(edgeID, newCost) print("The new cost of {0} is {1}\n".format(edgeID, graph.getCostOf(edgeID)))
def removeEdge(graph: DirectedGraph): ''' Function that remove an edge ''' vS = int(input(" starting edge : ")) vE = int(input(" end edge : ")) graph.removeEdge(vS, vE) print("Edge {0} -> {1} deleted!".format(vS, vE))
def setUp(self): self.fr = DirectedGraph() self.fr.add_edge('sten', 'sho') self.fr.add_edge('sten', 'agito') self.fr.add_edge('sho', 'zina') self.fr.add_edge('sho', 'tom') self.fr.add_edge('tom', 'jerry') self.fr.add_edge('zina', 'agito') self.fr.add_edge('zina', 'sho')
def EM_run_0(): print "BFS test" graph = DirectedGraph(5, [0.5 ,0.5]) graph.draw_edge(0, 2) graph.draw_edge(1, 2) graph.draw_edge(2, 3) graph.draw_edge(2, 4) graph.all_nodes[1].count_all_predecessor()
class TestGraph(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() self.graph.add_edge('Ivan', 'Ivo') self.graph.add_edge('Ivan', 'Joro') self.graph.add_edge('Joro', 'Krasi') self.graph.add_edge('Krasi', 'Rado') def test_add_edge(self): self.assertIn('Ivan', self.graph.nodes) self.assertIn('Ivo', self.graph.nodes) self.assertIn('Ivo', self.graph.nodes['Ivan']) def test_get_neighbours_for(self): self.assertSetEqual( self.graph.get_neighbours_for('Ivan'), {'Ivo', 'Joro'}) def test_path_between_exists(self): self.assertTrue(self.graph.path_between('Ivan', 'Rado')) def test_path_between_not_exist(self): self.assertFalse(self.graph.path_between('Krasi', 'Joro')) def test_str_graph(self): print(self.graph)
class TestGraph(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() self.graph.add_edge('Ivan', 'Ivo') self.graph.add_edge('Ivan', 'Joro') self.graph.add_edge('Joro', 'Krasi') self.graph.add_edge('Krasi', 'Rado') def test_add_edge(self): self.assertIn('Ivan', self.graph.nodes) self.assertIn('Ivo', self.graph.nodes) self.assertIn('Ivo', self.graph.nodes['Ivan']) def test_get_neighbours_for(self): self.assertSetEqual(self.graph.get_neighbours_for('Ivan'), {'Ivo', 'Joro'}) def test_path_between_exists(self): self.assertTrue(self.graph.path_between('Ivan', 'Rado')) def test_path_between_not_exist(self): self.assertFalse(self.graph.path_between('Krasi', 'Joro')) def test_str_graph(self): print(self.graph)
def test_dfs_directed(self): graph = DirectedGraph(7) graph.add_edge(0, 6) graph.add_edge(0, 2) graph.add_edge(0, 1) graph.add_edge(0, 5) graph.add_edge(6, 4) graph.add_edge(4, 5) graph.add_edge(4, 3) graph.add_edge(5, 3) self.assertEqual(graph.dfs(0), [None, 0, 0, 5, 6, 4, 0])
def test_bfs_directed(self): graph = DirectedGraph(6) graph.add_edge(0, 2) graph.add_edge(0, 1) graph.add_edge(0, 5) graph.add_edge(2, 1) graph.add_edge(2, 3) graph.add_edge(2, 4) graph.add_edge(4, 3) graph.add_edge(5, 3) self.assertEqual(graph.bfs(0), [None, 0, 0, 2, 2, 0])
def addVertex(graph: DirectedGraph): ''' Function that add a vertex ''' while True: vertex = int(input(" vertex id : ")) if graph.vertexExists(vertex): print("This vertex already exists!") else: graph.addVertex(vertex) print("The new vertex is named ", graph.vertices) break
def removeVertex(graph: DirectedGraph): ''' Function that remove a vertex ''' while True: vertex = int(input(" vertex id : ")) if graph.vertexExists(vertex): graph.removeVertex(vertex) print("Deletion completed") break else: print("This vertex does not exists!")
def edgeBetween(graph: DirectedGraph): ''' Functions that check if there is an edge between 2 vertex ''' x = int(input(" vertexStart : ")) y = int(input(" vertexIn : ")) if graph.vertexExists(x) and graph.vertexExists(y): if graph.isEdge(x, y): print("There is an edge!\n") else: print("There is not an edge!\n") else: print("One or both vertices does not exists!")
def addEdge(graph: DirectedGraph): ''' Function that add an edge ''' while True: vS = int(input(" starting edge : ")) vE = int(input(" end edge : ")) cost = int(input(" cost : ")) id = int(input(" id : ")) try: graph.addEdge(vS, vE, cost, id) break except Exception as ex: print(ex)
def get_order(self, dict): """ :param dict: List[String] :return: List[String] """ g = DirectedGraph(26) for i in range(0, len(dict)-1): self.build_graph(g, dict[i], dict[i+1]) # order must exist, no need to check cycle order = g.topo_sort() ret = [] for c in order: ret.append(chr(c + ord('a'))) return ret
class GetFollowers(): def __init__(self): self.dict_of_following = {} self.list_of_follwoers_names = [] self.dg = DirectedGraph() def folling(self, user_name): git_user_url = "https://api.github.com/users/{}/following".format(user_name) my_request = requests.get(git_user_url, auth=(TOKEN, '')) #print(my_request.encoding) if my_request.status_code == 200: self.dict_of_following = my_request.json() #print(self.dict_of_following) self.list_of_follwoers_names = [] for user in self.dict_of_following: self.list_of_follwoers_names.append(user["login"]) return self.list_of_follwoers_names else: print("f**k you") def metoda(self, user): for follower in self.folling(user): self.dg.add_edge(user, follower) for follower2 in self.folling(follower): self.dg.add_edge(follower, follower2) for follower3 in self.folling(follower2): self.dg.add_edge(follower2, follower3) for follower4 in self.folling(follower3): self.dg.add_edge(follower3, follower4) def print_following(self): for person in self.dict_of_following: print(person["login"])
class DirectedGraphTestClass(unittest.TestCase): def setUp(self): self.test_graph_info = {"a": ["b", "c"], "b": ["c"], "c": ["d"], "d": []} self.test_graph = DirectedGraph() self.test_graph.graph = self.test_graph_info def test_init(self): self.assertTrue(isinstance(self.test_graph, DirectedGraph)) def test_add_node(self): self.test_graph.add_node("p") self.assertTrue("p" in self.test_graph.graph.keys()) def test_add_edge(self): self.test_graph.add_edge("c", "a") self.assertTrue("a" in self.test_graph.graph["c"]) def test_get_neighbours_for(self): self.assertEqual(self.test_graph.get_neighbours_for("a"), ["b", "c"]) def test_path_between(self): self.assertTrue(self.test_graph.path_between("b", "c")) self.assertFalse(self.test_graph.path_between("c", "b")) self.assertTrue(self.test_graph.path_between("a", "d"))
class GithubFollowGraph: FOLLOWING_URL = 'https://api.github.com/users/{}/following' with open('token.txt', 'r') as token_file: content = token_file.readline()[:-1] token = (content, '') def __init__(self, username, depth): self.graph = DirectedGraph() self.main_user = username self.depth = depth followers = [self.main_user] current_depth = 0 while current_depth < depth: new_followers = [] for follower in followers: followings = GithubFollowGraph._get_following(follower) new_followers.extend(followings) for following in followings: self.graph.add_edge(follower, following) followers = new_followers current_depth += 1 @staticmethod def _get_following(username): url = GithubFollowGraph.FOLLOWING_URL.format(username) request = requests.get(url, auth=GithubFollowGraph.token) request.raise_for_status() following = [person['login'] for person in request.json()] return following def following(self): return list(self.graph.get_neighbours_for(self.main_user)) def is_following(self, username): return username in self.following() def steps_to(self, username): last_level = [self.main_user] counter = 0 while counter <= self.depth: next_level = set() if username in last_level: return counter for person in last_level: next_level = next_level.union( self.graph.get_neighbours_for(person)) last_level = next_level counter += 1 return 0
def transposeGraph(graph: DirectedGraph) -> DirectedGraph: new_graph = DirectedGraph() for vertex_id in graph.vertices: new_graph.addVertex(vertex_id, graph.getVertexLabel(vertex_id)) for vertex_id in graph.vertices: for vertex_neighbor_id in graph.getVertexNeighbors(vertex_id): new_graph.addEdge(vertex_neighbor_id, vertex_id, graph.weight(vertex_id, vertex_neighbor_id)) return new_graph
def __init__(self, username, depth): self.graph = DirectedGraph() self.main_user = username self.depth = depth followers = [self.main_user] current_depth = 0 while current_depth < depth: new_followers = [] for follower in followers: followings = GithubFollowGraph._get_following(follower) new_followers.extend(followings) for following in followings: self.graph.add_edge(follower, following) followers = new_followers current_depth += 1
def setUp(self): self.graph = DirectedGraph() self.graph.add_edge("Pesho", "Ivo") self.graph.add_edge("Ivan", "Ivo") self.graph.add_edge("Gosho", "Ivo") self.graph.add_edge("Ivan", "Pesho") self.graph.add_edge("Ivo", "Ivan")
def endpointsOfEdge(graph: DirectedGraph): ''' Function that prints the endpoints of an edge ''' edgeID = int(input(" edge id : ")) print("The endpoints of edge with ID {0} are:".format(edgeID), graph.getEndpointsOf(edgeID), "\n")
def main(): ''' Main program ''' graph = DirectedGraph("graph1k.txt") #print(graph) cmdDict = {0: UI.exitApp, 1: UI.nrOfVertices, 2: UI.edgeBetween, 3: UI.inOutDegree, 4: UI.outboundEdges, 5: UI.inboundEdges, 6: UI.endpointsOfEdge, 7: UI.retriveCost, 8: UI.modifyCost, 9: UI.addVertex, 10: UI.removeVertex, 11: UI.addEdge, 12: UI.removeEdge, 13: UI.saveGraph, 14: UI.printMenu} UI.printMenu() UI.Print(graph) while True: try: cmd = UI.readCommand() cmdDict[cmd](graph) except Exception as ex: traceback.print_exc() print(ex)
def create_random_graph(vertices, edges): """ creates random graph with the number of vertices and edges given. :param vertices: number of vertices :param edges: number of edges :return: """ graph = DirectedGraph(vertices) number_of_edges = 0 while number_of_edges < edges: x = randint(0, vertices - 1) y = randint(0, vertices - 1) if not graph.is_edge_between(x, y): graph.add_edge(x, y, randint(0, 1000)) number_of_edges += 1 return deepcopy(graph)
def deepFirstSearch(graph: DirectedGraph, init_vertex_id: str, visited: set) -> list: result_search = [init_vertex_id] visited.add(init_vertex_id) for vertex_id in graph.getVertexNeighbors(init_vertex_id): if vertex_id not in visited: result_search += deepFirstSearch(graph, vertex_id, visited) return result_search
def retriveCost(graph: DirectedGraph): ''' Function that print the cost of an edge ''' edgeID = int(input(" edge id : ")) print("The cost of edge with ID {0} is:".format(edgeID), graph.getCostOf(edgeID), "\n")
def inboundEdges(graph: DirectedGraph): ''' Function that prints the inbound edges of a vertex ''' vertex = int(input(" vertex : ")) print("Inbound edges of {0}:".format(vertex), graph.inboundEdgesOf(vertex), "\n")
def run(): graph = DirectedGraph() #random_graph(graph, 100, 10) load_from_file(graph, "graph5.txt") service = Service(graph) ui = UI(graph, service) ui.run() save_to_file(graph, "graph_out.txt")
def save_to_file(graph: DirectedGraph, file_name: str): with open(file_name, 'w') as data_file: output = f"{graph.vertices_count} {graph.edges_count}\n" for edge in graph.parse_edges(): output += f"{edge.start} {edge.end} {edge.cost}\n" data_file.write(output)
def worker_task(i): global logger if logger is None: logging.basicConfig( format= "%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s" ) fileHandler = logging.FileHandler('RD_log.log.{}'.format(os.getpid()), mode='w') logger = logging.getLogger() logger.addHandler(fileHandler) logger.setLevel(logging.DEBUG) random.seed(datetime.now()) start_time = time.time() rounds = 10 NODES = 7115 min_edges = 75000 max_edges = 125000 incr = 0.001 p = random.uniform(0.0015, 0.0024) # probability seed = 100 logger.info("# iteration {}".format(i + 1)) graph = None edges, avgc = -1, -1 while p > 0: logger.info("generating graph with N={} p={}".format(NODES, p)) graph = DirectedGraph.randomDirectedGraph(NODES, p) edges = graph.size()[1] avgc = graph.toUndirect().average_clustering() logger.info("prob={} edges={}".format(p, edges)) if edges >= min_edges and edges <= max_edges: break # avgc = graph.average_clustering() # logger.info("** avgc={}".format(avgc)) # if avgc >= 0.1 and avgc <= 0.2: # break # elif avgc > 0.2: # p += ((max_edges - edges) / min_edges * 10.0) * incr # else: # p += ((min_edges - edges) / min_edges * 10.0) * incr elif edges > max_edges: p += ((max_edges - edges) / min_edges) * incr else: p += ((min_edges - edges) / min_edges) * incr sys.stdout.flush() #graph.setLogger(logger) ret = experiment(graph, seed, rounds) elapsed = time.time() - start_time ret.append((edges, avgc, elapsed)) logger.info("# iteration %d done in %f" % (i + 1, time.time() - start_time)) logger.info("# {}".format(ret)) #gc.collect() #return [(lin_max_seed, max_lin_influenced), (eigenc_max_seed, max_eigenc_influenced), (bet_max_seed, max_bet_influenced)] return ret
def deepFirstSearchWithInverseOrder(graph: DirectedGraph, initial_vertex: str, stack: list, visited: set): visited.add(initial_vertex) for vertex_id in graph.getVertexNeighbors(initial_vertex): if vertex_id not in visited: deepFirstSearchWithInverseOrder(graph, vertex_id, stack, visited) stack.insert(0, initial_vertex)
def setUp(self): self.graph = DirectedGraph() self.graph.add_edge("Pesho", "Tisho") self.graph.add_edge("Pesho", "Gosho") self.graph.add_edge("Tisho", "Grisho") self.graph.add_edge("Rafa", "Grisho") self.graph.add_edge("Grisho", "Tisho") self.graph.add_edge("Grisho", "Rafa") self.graph.get_neighbors_for("Grisho") self.graph.path_between("Pesho", "Rafa")
class GitHubNetwork: def __init__(self, user_url): self.user_url = user_url self.user_network = DirectedGraph() self.user = User(user_url) self.user.make_followers() self.user.make_following() def build_network(self, user_url, level): current_level = 0 visited = set() visited.add(self.user) queue = [] queue.append((current_level, self.user), ) while len(queue) != 0: current_level, current_user = queue.pop(0) if current_level + 1 > level: break current_user.make_followers() current_user_followers = current_user.get_followers() current_user.make_following() current_user_following = current_user.get_following() for follower in current_user_followers: if follower not in visited: self.user_network.add_edge(current_user, follower) queue.append((current_level + 1, follower), ) visited.add(follower) for following in current_user_following: if following not in visited: self.user_network.add_edge(following, current_user) queue.append((current_level + 1, follower), ) visited.add(follower) def do_you_follow(self, user_followed): return self.user_network.edge_between(self.user, user_followed) def do_you_follow_indirectly(self, user_following): return self.user_network.path_between(self.user, user_following) def does_he_she_follows(self, user_following): self.user.make_following() if user_following.login in self.user.get_following(): return True else: return False def does_he_she_follow_indirectly(self, user_following): return self.user_network.path_between(user_following, self.user)
def worker_task(i): global logger if logger is None: logging.basicConfig(format="%(asctime)s [%(process)-4.4s--%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s") fileHandler = logging.FileHandler('RD_log.log.{}'.format(os.getpid()),mode='w') logger=logging.getLogger() logger.addHandler(fileHandler) logger.setLevel(logging.DEBUG) random.seed(datetime.now()) start_time = time.time() rounds = 10 NODES = 7115 min_edges = 75000 max_edges = 125000 incr = 0.001 p = random.uniform(0.0015, 0.0024) # probability seed = 100 logger.info("# iteration {}".format(i+1)) graph = None edges, avgc = -1, -1 while p > 0: logger.info("generating graph with N={} p={}".format(NODES, p)) graph = DirectedGraph.randomDirectedGraph(NODES, p) edges = graph.size()[1] avgc = graph.toUndirect().average_clustering() logger.info("prob={} edges={}".format(p, edges)) if edges >= min_edges and edges <= max_edges: break # avgc = graph.average_clustering() # logger.info("** avgc={}".format(avgc)) # if avgc >= 0.1 and avgc <= 0.2: # break # elif avgc > 0.2: # p += ((max_edges - edges) / min_edges * 10.0) * incr # else: # p += ((min_edges - edges) / min_edges * 10.0) * incr elif edges > max_edges: p += ((max_edges - edges) / min_edges) * incr else: p += ((min_edges - edges) / min_edges) * incr sys.stdout.flush() #graph.setLogger(logger) ret = experiment(graph, seed, rounds) elapsed = time.time() - start_time ret.append((edges, avgc, elapsed)) logger.info("# iteration %d done in %f" % (i+1, time.time() - start_time)) logger.info("# {}".format(ret)) #gc.collect() #return [(lin_max_seed, max_lin_influenced), (eigenc_max_seed, max_eigenc_influenced), (bet_max_seed, max_bet_influenced)] return ret
def topologialSort(graph: DirectedGraph) -> str: stack = list() visited = set() for vertex_id in graph.vertices: if vertex_id not in visited: deepFirstSearchWithInverseOrder(graph, vertex_id, stack, visited) stack_labels = list() for vertex_id in stack: stack_labels.append(graph.getVertexLabel(vertex_id)) return ' -> '.join(stack_labels) + '\n'
def load_activities(graph: DirectedGraph, file_name: str): with open(file_name, 'r') as data_file: first_line = data_file.readline() activity_count = first_line activity_count = int(activity_count) for i in range(activity_count + 1): graph.add_vertex(i) for i, line in enumerate(data_file): (prerequisites_str, duration) = line.split(' ') prerequisites_str = prerequisites_str.split(',') prerequisites = [] for prerequisite_str in prerequisites_str: prerequisites.append(int(prerequisite_str)) duration = int(duration) for prerequisite in prerequisites: graph.add_edge(prerequisite, i + 1, duration)
def buildGraphFromFile(file_path: str, is_directed: bool = False): graph_file = open(file_path, 'r') if is_directed: graph = DirectedGraph() else: graph = NotDirectedGraph() graph_file.readline() #ignoring first line build_vertices = True for line in graph_file: line = line.rstrip("\n\r").rstrip(' ') #remove new line character and spaces in the end of the line if build_vertices: if line in {"*edges"} or line in {"*arcs"}: build_vertices = False else: try: splittedLine = line.split(' ', 1) if len(splittedLine) == 2: vertexId = splittedLine[0] vertexName = splittedLine[1].replace("\"", "") graph.addVertex(vertexId, vertexName) else: raise Exception("Error while building vertex (graph = "+file_path+"): \""+line+"\" isn't in the default template: (id label)") except Exception as error: print("(graph = "+file_path+"):"+str(error)) return NotDirectedGraph() else: try: splittedLine = line.split(' ') if len(splittedLine) == 3: origin_vertex_id = splittedLine[0] destiny_vertex_id = splittedLine[1] edge_weight = float(splittedLine[2]) graph.addEdge(origin_vertex_id, destiny_vertex_id, edge_weight) else: raise Exception("Error while building edge (graph = "+file_path+"): \""+line+"\" isn't in the default template: (id id weight)") except ValueError: print("Error while building edge (graph = "+file_path+"): \""+splittedLine[2]+"\" (your weight) isn't a float") return NotDirectedGraph() except Exception as error: print("(graph = "+file_path+"): "+str(error)) return NotDirectedGraph() return graph
class GitHubSocialNetwork: def __init__(self, user): self.user = user self.graph = DirectedGraph() def __followers_caller(self, user): client_id = "f8be3d072416ea05b379" client_secret = "63f1f862a9c6c2b892dcc577f462b1cb0f095722" data = 'https://api.github.com/users/{}/following'.format(user) data += '?client_id={}&client_secret={}'.format(client_id, client_secret) return data def __graph_level_builder(self, user, graph): r = requests.get(self.__followers_caller(user)) for follower in json.loads(r.text): graph.add_edge(user, follower["login"]) def __graph_builder(self, user, depth, graph, max_depth): if (depth > max_depth): return self.__graph_level_builder(user, graph) for follower in graph.graph[user]: self.__graph_builder(follower, depth + 1, graph, max_depth) def __graph_init(self, max_depth): if (max_depth >= 4): raise ValueError("So Deep") self.__graph_builder(self.user, 0, self.graph, max_depth) def following(self): graph = DirectedGraph() self.__graph_level_builder(self.user, graph) return graph.graph[self.user] def is_following(self, followed): return followed in self.following() def steps_to(self, username): self.__graph_init(3) return self.graph.steps_between(self.user, username)
def EM_run_8(): print "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" print "Experiment run 8: [tt, tf, ft, ff] = [0.9, 0.6, 0.3, 0.2]" print "Multiple recovery" print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" graph = DirectedGraph(5, [0.5 ,0.5]) graph.draw_edge(0, 2) graph.draw_edge(1, 2) graph.draw_edge(2, 3) graph.draw_edge(2, 4) graph.init_CPT() graph.set_node_est_CPT(0, [0.1]) graph.set_node_est_CPT(1, [0.2]) graph.set_node_est_CPT(2, [0.2, 0.3, 0.6, 0.9]) #graph.set_node_est_CPT(2, [0.1, 0.1, 0.2, 0.2]) graph.set_node_est_CPT(3, [0.2, 0.9]) graph.set_node_est_CPT(4, [0.1, 0.8]) ''' samples = [] for i in range(100): curr_sample = [] for j in range(5): curr_sample.append(round(random.random(), 0)) samples.append(curr_sample) samples = np.array(samples, dtype=np.int64) ''' samples = np.array([[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [1, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 1, 1, 1, 0], [0, 0, 0, 0, 1], [1, 1, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 1, 1, 0], [0, 0, 0, 0, 1]]) graph.EM(samples, 2, 10000) graph.EM(samples, 3, 10000)
def EM_run_9(): print "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" print "Experiment run 9: [tt, tf, ft, ff] = [0.9, 0.6, 0.3, 0.2]" print "RANDOM DATA - Varying Sample size (double)" print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" iters = 0 simulations = 1000 runs = [] for i in range(simulations): graph = DirectedGraph(5, [0.5 ,0.5]) graph.draw_edge(0, 2) graph.draw_edge(1, 2) graph.draw_edge(2, 3) graph.draw_edge(2, 4) graph.init_CPT() graph.set_node_est_CPT(0, [0.1]) graph.set_node_est_CPT(1, [0.2]) graph.set_node_est_CPT(2, [0.2, 0.3, 0.6, 0.9]) graph.set_node_est_CPT(3, [0.2, 0.9]) graph.set_node_est_CPT(4, [0.1, 0.8]) samples = [] for i in range(100): curr_sample = [] for j in range(5): curr_sample.append(round(random.random(), 0)) samples.append(curr_sample) samples = np.array(samples, dtype=np.int64) #print "RANDOM DATA" #print str(samples) ret = graph.EM(samples, 2, 1000) iters += ret runs.append(ret) print "Took approximately: " + str(iters/simulations) plt.figure() plt.hist(runs, bins=50) plt.title('Distribution of Iterations Until Converged') plt.xlabel('Number of Iterations') plt.ylabel('Frequency') plt.savefig('dist_9.png') print "Took approximately: " + str(iters/simulations)
def setUp(self): self.new_graph = DirectedGraph()
def EM_run_6b(): #print "\n Experiment run 6: [tt, tf, ft, ff] = [0.9, 0.6, 0.3, 0.2]" #print "RANDOM DATA" iters = 0 simulations = 10000 graph = DirectedGraph(5, [0.5 ,0.5]) graph.draw_edge(0, 2) graph.draw_edge(1, 2) graph.draw_edge(2, 3) graph.draw_edge(2, 4) graph.init_CPT() graph.set_node_est_CPT(0, [0.1]) graph.set_node_est_CPT(1, [0.2]) graph.set_node_est_CPT(2, [0.2, 0.3, 0.6, 0.9]) graph.set_node_est_CPT(3, [0.2, 0.9]) graph.set_node_est_CPT(4, [0.1, 0.8]) samples = [] for i in range(100): curr_sample = [] for j in range(5): curr_sample.append(round(random.random(), 0)) samples.append(curr_sample) samples = np.array(samples, dtype=np.int64) #print "RANDOM DATA" #print str(samples) return graph.EM(samples, 2, 10000)
def __init__(self): self.dict_of_following = {} self.list_of_follwoers_names = [] self.dg = DirectedGraph()
class DirectedClassTest(unittest.TestCase): def setUp(self): self.new_graph = DirectedGraph() def test_init(self): self.assertEqual(self.new_graph.graph, {}) def test_add_edge(self): self.new_graph.add_edge("Ivan", "Petar") self.new_graph.add_edge("Petar", "Georgi") self.assertEqual(self.new_graph.graph, {"Ivan": ["Petar"], "Petar": ["Georgi"], "Georgi": []}) def test_get_neighbours(self): self.new_graph.add_edge("Ivan", "Petar") self.new_graph.add_edge("Petar", "Georgi") self.assertEqual(self.new_graph.get_neighbours_for("Ivan"), ["Petar"]) self.assertEqual(self.new_graph.get_neighbours_for("Petar"), ["Georgi"]) def test_path_between_direct_neighbours(self): self.new_graph.add_edge("Ivan", "Petar") self.assertTrue(self.new_graph.path_between("Ivan", "Petar")) def test_path_between_false(self): self.new_graph.add_edge("Ivan", "Petar") self.new_graph.add_edge("Valeri", "Georgi") self.assertFalse(self.new_graph.path_between("Ivan", "Dragan")) self.assertFalse(self.new_graph.path_between("Ivan", "Georgi")) def test_path_between_distant_neighbour(self): self.new_graph.add_edge("Ivan", "Petar") self.new_graph.add_edge("Petar", "Georgi") self.assertTrue(self.new_graph.path_between("Ivan", "Georgi")) def test_path_between_cycle(self): self.new_graph.add_edge("Ivan", "Petar") self.new_graph.add_edge("Petar", "Ivan") self.assertTrue(self.new_graph.path_between("Petar", "Ivan")) def test_path_between_cycles(self): self.new_graph.add_edge("1", "2") self.new_graph.add_edge("2", "1") self.new_graph.add_edge("2", "3") self.new_graph.add_edge("3", "2") self.new_graph.add_edge("3", "1") self.new_graph.add_edge("2", "4") self.new_graph.add_edge("4", "2") self.new_graph.add_edge("4", "3") self.new_graph.add_edge("4", "1") self.new_graph.add_edge("3", "5") self.assertTrue(self.new_graph.path_between("1", "5"))
def setUp(self): self.node_one = Node('Penko') self.node_two = Node('Penka') self.graph = DirectedGraph()
def test_edge_added_directed(self): graph = DirectedGraph(7) graph.add_edge(2, 9) self.assertEqual(graph.edge, 0) self.assertEqual(graph.adj_list[2], []) self.assertNotEqual(len(graph.adj_list), 9) graph.add_edge(0, 1) graph.add_edge(0, 5) graph.add_edge(6, 0) graph.add_edge(6, 4) graph.add_edge(2, 3) self.assertEqual(graph.adj_list[2], [3]) self.assertEqual(graph.adj_list[3], []) graph.add_edge(3, 2) self.assertEqual(graph.adj_list[2], [3]) self.assertEqual(graph.adj_list[3], [2]) graph.add_edge(2, 0) graph.add_edge(3, 5) graph.add_edge(4, 2) graph.add_edge(4, 3) graph.add_edge(5, 4) self.assertEqual(graph.edge, 11)
class TestDirectedGraph(unittest.TestCase): def setUp(self): self.node_one = Node('Penko') self.node_two = Node('Penka') self.graph = DirectedGraph() def test_add_edge(self): self.graph.add_edge(self.node_one, self.node_two) self.assertIn(self.node_one, self.graph.nodes[self.node_two.name].is_pointed_by) self.assertIn(self.node_two, self.graph.nodes[self.node_one.name].points_to) def test_get_neighbours_for(self): pencho = Node('Pencho') self.graph.add_edge(self.node_one, self.node_two) self.graph.add_edge(self.node_one, pencho) self.assertEqual([self.node_two, pencho], self.graph.get_neighbours_for(self.node_one)) def test_path_between_normal(self): self.graph.add_edge(self.node_one, self.node_two) self.assertTrue(self.graph.path_between(self.node_one, self.node_two)) self.assertFalse(self.graph.path_between(self.node_two, self.node_one)) def test_path_between_rare(self): penichka = Node('Penichka') self.graph.add_edge(self.node_one, self.node_two) self.graph.add_edge(self.node_two, penichka) self.assertTrue(self.graph.path_between(self.node_one, penichka)) def test_path_between_recursion(self): uno = Node('1') dos = Node('2') tres = Node('3') quatro = Node('4') cinco = Node('5') seis = Node('6') self.graph.add_edge(uno, dos) self.graph.add_edge(dos, tres) self.graph.add_edge(dos, quatro) self.graph.add_edge(quatro, cinco) self.graph.add_edge(quatro, seis) self.graph.add_edge(tres, dos) self.assertTrue(self.graph.path_between(uno, seis))
class TestGraph(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() self.graph.add_edge("Ivo", "Hrisi") self.graph.add_edge("Pesho", "Ivo") self.graph.add_edge("Pesho", 'a') self.graph.add_edge("Niki", "Georgi") def test_addEdge(self): self.assertIn(("Niki", "Georgi"), self.graph.edges) self.assertIn("Niki", self.graph.nodes) self.assertIn("Georgi", self.graph.nodes) def test_get_neighbours(self): self.assertIn("a", self.graph.get_neighbors_for("Pesho")) self.assertIn("Ivo", self.graph.get_neighbors_for("Pesho")) self.assertIn("Hrisi", self.graph.get_neighbors_for('Ivo')) def test_path_between(self): self.assertTrue(self.graph.path_between("Ivo", "Hrisi")) self.assertFalse(self.graph.path_between("Hrisi", "Ivo")) self.assertTrue(self.graph.path_between("Niki", "Georgi")) self.assertTrue(self.graph.path_between("Pesho", "Hrisi")) @unittest.skip("Just testing print") def test_print(self): print(self.graph) self.assertTrue(False)
def setUp(self): self.graph = DirectedGraph() self.graph.add_edge("Ivo", "Hrisi") self.graph.add_edge("Pesho", "Ivo") self.graph.add_edge("Pesho", 'a') self.graph.add_edge("Niki", "Georgi")
def test_out_degree_directed(self): graph = DirectedGraph(7) graph.add_edge(0, 1) graph.add_edge(0, 5) self.assertEqual(graph.out_degree(0), 2)
class DirectedGraphTests(unittest.TestCase): def setUp(self): self.graph = DirectedGraph() self.graph.add_edge("Pesho", "Ivo") self.graph.add_edge("Ivan", "Ivo") self.graph.add_edge("Gosho", "Ivo") self.graph.add_edge("Ivan", "Pesho") self.graph.add_edge("Ivo", "Ivan") def test_add_edge(self): self.assertEqual(len(self.graph.graph), 4) def test_get_neighbors(self): self.assertEqual(len(self.graph.graph['Ivan']), 2) def test_path_between(self): self.assertTrue(self.graph.path_between("Pesho", "Ivo")) self.assertTrue(self.graph.path_between("Ivo", "Pesho")) self.assertFalse(self.graph.path_between("Ivan", "Gosho")) def test_steps_between(self): self.assertEqual(self.graph.steps_between("Pesho", "Pesho"), 0) self.assertEqual(self.graph.steps_between("Ivan", "Pesho"), 1) self.assertEqual(self.graph.steps_between("Pesho", "Ivan"), 2) self.assertEqual(self.graph.steps_between("Gosho", "Pesho"), 3) def test_to_string(self): test_string = str(self.graph) self.assertEqual(len(test_string), 71)
def EM_run_3(): print "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" print "Experiment run 3: [tt, tf, ft, ff] = [0.9, 0.9, 0.9, 0.9]" print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" graph = DirectedGraph(5, [0.5 ,0.5]) graph.draw_edge(0, 2) graph.draw_edge(1, 2) graph.draw_edge(2, 3) graph.draw_edge(2, 4) graph.init_CPT() graph.set_node_est_CPT(0, [0.1]) graph.set_node_est_CPT(1, [0.2]) graph.set_node_est_CPT(2, [0.9, 0.9, 0.9, 0.9]) graph.set_node_est_CPT(3, [0.2, 0.9]) graph.set_node_est_CPT(4, [0.1, 0.8]) samples = np.array([[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [1, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 1, 0, 1, 0], [0, 0, 0, 0, 1], [1, 1, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]) graph.EM(samples, 2, 100)
def test_max_degree_directed(self): graph = DirectedGraph(7) graph.add_edge(0, 1) graph.add_edge(2, 1) self.assertEqual(graph.max_degree(), 2)