def _eliminate_edges(self, Sep): num_nodes = len(self._values_dict.keys()) graph = complete_graph(num_nodes, Graph()) self._graph = GraphUtils.rename_nodes(graph, self._node_names) n = 0 max_allowed_degree = settings.networks_settings['genome']['max_allowed_degree'] while n <= 3: print '--------------------------------------------------------' # We repeat the iterations unless each node X has # less than or equal to n neighbors for X in self._graph: for Y in self._graph: if X != Y and GraphUtils.is_degree_greater(self._graph, max_allowed_degree) \ and is_connected(self._graph): # all the neighbors of X excluding Y neighbors = self._graph.neighbors(X) if Y in neighbors: neighbors.remove(Y) # We only consider X,Y if #neighbors of X excluding Y are more than # or equal to n if len(neighbors) >= n: # Combinations of all the adjacent nodes of X excluding Y # each subset in the observed_sets has cardinality 'n' observed_subsets = combinations(neighbors, n) for S in observed_subsets: # We only consider the subsets which have exactly S = [s for s in sorted(S)] are_deseparated = self._are_dseparated(X, Y, S, n) if are_deseparated: if self._graph.has_edge(X, Y): self._graph.remove_edge(X, Y) print 'Removed', X, '-', Y Sep[X + ',' + Y] = S Sep[Y + ',' + X] = S n += 1
def test(): generator = RandomBNGenerator('cancer', 3, max_parents = 2); bns = generator.get_bayesian_networks() for bn in bns: print bn.nodes() print GraphUtils.has_cycle(bn) draw(bn) plt.show()
def main(): # Creating a random unidirectional graph graph = GraphUtils.generate_graph(10, 25) # Creating a list of random colors colors = GraphUtils.generate_colors(10) # Execute the 'FirsFit' heuristic on the generated graph graph_color = FirstFit.execute(graph, colors) # Displaying the graph inside file GraphUtils.display_graph(graph, graph_color, "FirstFit")
def get_bayesian_networks(self): bayesian_network = GraphUtils.read_graph(self._network_name + '-' + str(self._max_parents)) bayesian_networks = [] if bayesian_network == None: # Generate a tree (graph) with required number of nodes. bayesian_network = self._generate_initial_graph() bayesian_network.name = self._network_name + '-' + str(self._max_parents) GraphUtils.write_graph(bayesian_network) # theoretical bound is infinity but this also does well num_iterations = 4 * self._num_nodes * self._num_nodes # Since connectedness is only defined for undirected graphs # so we have to keep a copy of the bayesian network # except that all the edges are undirected undirected_BN = bayesian_network.to_undirected() bayesian_network.name = self._network_name # Repeat for a large number of times. for i in xrange(self._num_BNs): count, i, j = 0, 0, 0; while count < num_iterations: edge = (i, j) = GraphUtils.get_random_edge(self._node_names) if bayesian_network.has_edge(*edge): # If (i,j) is in the graph, remove it GraphUtils.apply_action(bayesian_network, undirected_BN, edge, 'remove', self._max_parents) else: # If the edge (i,j) is not in the graph, add it. GraphUtils.apply_action(bayesian_network, undirected_BN, edge, 'add', self._max_parents) count += 1 bayesian_networks.append(deepcopy(bayesian_network)) # Return the obtained graph return bayesian_networks
def perform_GHC(self): current_solution = self._bayesian_network self._best_score = current_score = self._get_score(current_solution) # draw(self._bayesian_network) # plt.show() print 'Initial score :', self._best_score undirected_graph = current_solution.to_undirected() change_count = 0 max_count = self._max_change_count print max_count while True: # Pick a random edge and decide the best action to be # applied on the edge random_edge = GraphUtils.get_random_edge(self._node_names) # print random_edge, ' is the edge selected' current_score, current_solution = \ self._get_best_local_solution(current_solution, undirected_graph, random_edge) undirected_graph = current_solution.to_undirected() if current_score > self._best_score: change_count = 0 # Update the new best solution self._best_solution = deepcopy(current_solution) self._best_score = current_score print '-----------', self._best_score , '------------------' else: change_count += 1 self._add_solution_to_tabu_list(current_solution) if change_count == max_count: break
def _get_feasible_local_solutions(self, bayesian_network, undirected_graph, edge): local_solutions_action_pairs = [] # Calculate all possible local solutions by applying # all the possible actions. temp_bn = deepcopy(bayesian_network) temp_graph = deepcopy(undirected_graph) for action in self._actions_list: # print action + 'ing', edge, ' in ', bayesian_network.edges() is_feasible = GraphUtils.apply_action(temp_bn, temp_graph, (edge), action, 2) if not is_feasible: # If the action was not feasible then try again # print 'Infeasible action.. trying with different action' continue if self._tabu_list_contains(temp_bn): # If generated solution is already in the tabu list then try again # print 'Solution already in tabu list trying again' continue # print 'Got ', temp_bn.edges() local_solutions_action_pairs.append((temp_bn, action)) temp_bn = deepcopy(bayesian_network) temp_graph = deepcopy(undirected_graph) return local_solutions_action_pairs
def get_skeleton(self): self._graph = GraphUtils.convert_to_directed(self._graph) self._graph.name = self._network_name return self._graph