def fit_sparsify(self, graph, iterations, weight="weight"):
""" Compute the sparsification features for the graph """
sparse_graph = self.copy_graph_blank(graph)
edges = self.run_sparsify(graph, iterations=iterations, weight=weight)
for num, edge_set in enumerate(edges):
weighted_edges = [edge + ((num + 1) / iterations, ) for edge in edge_set]
sparse_graph.add_weighted_edges_from(weighted_edges)
return graph_utils.get_weights(sparse_graph)
def define_edge_objective(variable_dict, graph, perturb=False):
""" Define all terms for the edge objective """
weights = np.array(graph_utils.get_weights(graph))
if perturb:
perturbs = ((weights - weights.mean())/weights.mean()) ** 2
perturbs = np.clip(perturbs * 2 -1, -1, 1)
randoms = np.random.uniform(low=0, high=0.3, size=len(weights))
perturbs = np.ones_like(randoms)
weights = weights + weights * perturbs * randoms
variables = [variable_dict["x_{},{}".format(*edge)] for edge in graph.edges]
return [var * weight for (var, weight) in zip(variables, weights)]
def compute_ff_edges(graph):
""" Compute the weight divided by the min right neighbour weight """
min_vertex = np.min(graph.nodes)
weights = 1 + np.array(graph_utils.get_weights(graph))
mins = [
1 + np.min(graph_utils.get_edge_weights(graph, node, out=False))
for node in graph.nodes
]
return np.array([
mins[edge[1] - min_vertex] / weight
for weight, edge in zip(weights, graph.edges)
])
def compute_fc_edges(graph):
""" Compute the weight divided by the max right neighbour weight """
min_vertex = np.min(graph.nodes)
weights = 1 + np.array(graph_utils.get_weights(graph))
maxes = [
1 + np.max(graph_utils.get_edge_weights(graph, node, out=False))
for node in graph.nodes
]
return np.array([
weight / maxes[edge[1] - min_vertex]
for weight, edge in zip(weights, list(graph.edges))
])
def plot_graph(graph,
edges=None,
weights=None,
weight="weight",
coord_dict=None,
withlabels=True):
""" Plot the given graph, plotting the given edges and weights (default all) """
coord_dict = coord_dict or generate_coord_dict(graph)
if edges is None:
edges = graph_utils.get_edges(graph)
if weights is None:
weights = weights or graph_utils.get_weights(graph, weight=weight)
check_indices(coord_dict, edges)
plot_vertices(coord_dict, withlabels=withlabels)
plot_edges(coord_dict, edges, weights)
def plot_weighted_graph(graph,
weight="weight",
title="Random Weighted Graph Plot"):
""" Plot the given graph, randomly positioning nodes """
coords = nx.spring_layout(graph)
xs = [coords[key][0] for key in coords.keys()]
ys = [coords[key][1] for key in coords.keys()]
plt.scatter(xs, ys, marker="x", color="purple")
for a, b, k in zip(xs, ys, coords.keys()):
plt.text(a, b, k)
edges, weights = graph_utils.get_edges(graph), graph_utils.get_weights(
graph, weight=weight)
for (edge, weight) in zip(edges, weights):
xs = (coords[edge[0]][0], coords[edge[1]][0])
ys = (coords[edge[0]][1], coords[edge[1]][1])
plt.plot(xs, ys, 'k-', lw=2, color="black", alpha=weight)
def compute_f12_edges(graph):
""" Compare the edges to the mean edge value """
weights = np.array(graph_utils.get_weights(graph))
return weights.flatten() / (np.max(weights) - np.min(weights))
def compute_f10_edges(graph):
""" Compare the edges to the max edge value """
weights = np.array(graph_utils.get_weights(graph))
return weights.flatten() / np.max(weights)
def compute_fd_edges(graph):
""" Compute the weight divided by the global max """
weights = np.array(graph_utils.get_weights(graph))
global_min = weights.min()
return (1 + global_min) / (1 + weights)
