def examine_graph(graph: Graph,
experiment: str,
graphname: str,
real: bool,
directed: bool = True) -> Properties:
vertices = graph.num_vertices()
edges = graph.num_edges()
total_degrees = graph.get_total_degrees(np.arange(vertices))
min_degree = np.min(total_degrees)
max_degree = np.max(total_degrees)
avg_degree = vertex_average(graph, "total")[0]
largest_component = extract_largest_component(
graph, directed=False).num_vertices()
num_islands = np.sum(total_degrees == 0)
cc = global_clustering(graph)[0]
# _degrees, _counts = np.unique(total_degrees, return_counts=True)
# log_degrees = np.log(_degrees)
# log_counts = np.log(_counts)
# regressor = LinearRegression()
# regressor.fit(log_degrees.reshape(-1, 1), log_counts)
# exponent = regressor.coef_[0]
result = powerlaw.Fit(total_degrees,
xmin=1,
discrete=True,
xmax=max_degree)
exponent = -result.alpha
percentile = np.percentile(total_degrees, 95)
# print("Exponent for this graph is: ", exponent)
# print("Using powerlaw package: e = {} xmin = {} xmax = {}".format(
# exponent2, result.xmin, result.xmax))
# print("degrees: {}\ncounts: {}".format(_degrees[:20], _counts[:20]))
return Properties(experiment, graphname, real, vertices, edges, min_degree,
max_degree, avg_degree, largest_component, num_islands,
cc, directed, exponent, percentile)
def f_local_clustering(D,
stats,
options={
'features': [],
'skip_features': []
}):
""""""
if not 'local_clustering' in options['features'] or (
'skip_features' in options
and 'local_clustering' in options['skip_features']):
log.debug('Skipping local_clustering')
return
stats['local_clustering'] = vertex_average(D, local_clustering(D))[0]
log.debug('done local_clustering')
def test_sredni_wspolczynnik_klasteryzacji_na_sztywno_graf_pelny(self):
# self.assertEqual(7. / 15, self.stat.sredni_wspolczynnik_klasteryzacji_moj())
# print self.stat.sredni_wspolczynnik_klasteryzacji_moj()
g = Graph(directed=False)
v0 = g.add_vertex()
v1 = g.add_vertex()
v2 = g.add_vertex()
v3 = g.add_vertex()
g.add_edge(v0, v1)
g.add_edge(v0, v2)
g.add_edge(v0, v3)
g.add_edge(v1, v2)
g.add_edge(v1, v3)
g.add_edge(v2, v3)
lc = local_clustering(g, undirected=True)
self.assertEqual(1.0, vertex_average(g, lc)[0])
def user_network_summary(g):
span = "{:D MMM YYYY, HH:mm} - {:D MMM YYYY, HH:mm}".format(
arrow.get(g.edge_properties["created_at"].a.min()),
arrow.get(g.edge_properties["created_at"].a.max())
)
largest_component = label_largest_component(g, directed=False).a.sum()
display(Markdown("### " + g.graph_properties["track"].replace("#", r"\#")))
display(Markdown("#### " + span))
graph_draw(g, inline=True, output_size=[1000, 1000],
vertex_fill_color=[.2, .3, .9, .7], vertex_size=2)
stats = pd.DataFrame([
["Vertices",
g.num_vertices()],
["Edges",
g.num_edges()],
["Avg. degree",
float(g.num_edges()) / g.num_vertices()],
["Avg. clustering",
vertex_average(g, local_clustering(g))[0]],
["Giant component share",
"{:.1%}".format(largest_component / g.num_vertices())]
], columns=["Metric", "Value"])
display(stats)
bins = 20
counts, _ = vertex_hist(g, "in", range(bins))
plt.bar(range(1, bins), counts, align="center")
plt.xticks(range(bins))
plt.xlim([0.5, bins - 1])
plt.title("Degree distribution")
plt.show()
def squaredAvg(graph):
return vertex_average(graph, 'out')[0]**2
def avg_path_length(g):
return np.sum(
gt_stats.vertex_average(g, gt.shortest_distance(g))[0]
) / (g.num_vertices() - 1)
def avg_degree(g):
return gt_stats.vertex_average(g, 'total')[0]
def lcl_clus_coef(g):
return gt_stats.vertex_average(g, gt.local_clustering(g))[0]