def get_partition_metrics(self):
partition_nonoverlapping_metrics = {}
partition_nonoverlapping_metrics = {}
partition_nonoverlapping_fieldnames = [
"file",
"partition",
"population",
"modularity",
"loneliness_score",
"network_permanence",
]
partition_overlapping_fieldnames = [
"file",
"partition",
"population",
"Q",
"NQ",
"Qds",
"intraEdges",
"interEdges",
"intraDensity",
"modularity degree",
"conductance",
"expansion",
"contraction",
"fitness",
"QovL",
]
partition_population = utils.get_partition_population(
self.G, self.assignments, self.num_partitions)
for p in range(0, self.num_partitions):
partition_overlapping_metrics = {
"file": self.metrics_timestamp,
"partition": p,
"population": partition_population[p][0]
}
partition_nonoverlapping_metrics = {
"file": self.metrics_timestamp,
"partition": p,
"population": partition_population[p][0]
}
nodes = [i for i, x in enumerate(self.assignments) if x == p]
Gsub = self.G.subgraph(nodes)
if self.verbose > 0:
print("\nPartition {} with {} nodes".format(
p, Gsub.number_of_nodes()))
print("-----------------------------\n")
file_oslom = utils.write_graph_files(self.OUTPUT_DIRECTORY,
"{}-p{}".format(
self.metrics_filename, p),
Gsub,
quiet=True)
# MaxPerm
max_perm = utils.run_max_perm(Gsub, relabel_nodes=True)
partition_nonoverlapping_metrics.update(
{"network_permanence": max_perm})
# Modularity
mod = utils.modularity(Gsub, best_partition=True)
partition_nonoverlapping_metrics.update({"modularity": mod})
# Loneliness Score
score = utils.loneliness_score(Gsub, self.loneliness_score_param)
partition_nonoverlapping_metrics.update(
{"loneliness_score": score})
# Community Quality metrics
community_metrics = utils.run_community_metrics(
self.OUTPUT_DIRECTORY, "{}-p{}".format(self.metrics_filename,
p), file_oslom)
partition_overlapping_metrics.update(community_metrics)
if self.verbose > 0:
print("\nMetrics")
for f in partition_overlapping_fieldnames:
print("{}: {}".format(f, partition_overlapping_metrics[f]))
for f in partition_nonoverlapping_fieldnames:
print("{}: {}".format(f,
partition_nonoverlapping_metrics[f]))
# write metrics to CSV
csv_file = os.path.join(self.OUTPUT_DIRECTORY,
"metrics-partitions-overlapping.csv")
utils.write_metrics_csv(csv_file, partition_overlapping_fieldnames,
partition_overlapping_metrics)
csv_file = os.path.join(self.OUTPUT_DIRECTORY,
"metrics-partitions-nonoverlapping.csv")
utils.write_metrics_csv(csv_file,
partition_nonoverlapping_fieldnames,
partition_nonoverlapping_metrics)
def get_graph_metrics(self):
self.metrics_timestamp = datetime.datetime.now().strftime('%H%M%S')
f, _ = os.path.splitext(os.path.basename(self.DATA_FILENAME))
self.metrics_filename = f + "-" + self.metrics_timestamp
graph_metrics = {
"file": self.metrics_timestamp,
"num_partitions": self.num_partitions,
"num_iterations": self.num_iterations,
"prediction_model_cut_off": self.prediction_model_cut_off,
"restream_batches": self.restream_batches,
"use_virtual_nodes": self.use_virtual_nodes,
"virtual_edge_weight": self.virtual_edge_weight,
}
graph_fieldnames = [
"file",
"num_partitions",
"num_iterations",
"prediction_model_cut_off",
"restream_batches",
"use_virtual_nodes",
"virtual_edge_weight",
"edges_cut",
"waste",
"cut_ratio",
"total_communication_volume",
"network_permanence",
"Q",
"NQ",
"Qds",
"intraEdges",
"interEdges",
"intraDensity",
"modularity degree",
"conductance",
"expansion",
"contraction",
"fitness",
"QovL",
]
if self.verbose > 0:
print("Complete graph with {} nodes".format(
self.G.number_of_nodes()))
file_oslom = utils.write_graph_files(self.OUTPUT_DIRECTORY,
"{}-all".format(
self.metrics_filename),
self.G,
quiet=True)
# original scoring algorithm
scoring = utils.score(self.G, self.assignments, self.num_partitions)
graph_metrics.update({
"waste": scoring[0],
"cut_ratio": scoring[1],
})
# edges cut and communication volume
edges_cut, steps = utils.base_metrics(self.G, self.assignments)
graph_metrics.update({
"edges_cut": edges_cut,
"total_communication_volume": steps,
})
# MaxPerm
max_perm = utils.run_max_perm(self.G)
graph_metrics.update({"network_permanence": max_perm})
# Community Quality metrics
community_metrics = utils.run_community_metrics(
self.OUTPUT_DIRECTORY, "{}-all".format(self.metrics_filename),
file_oslom)
graph_metrics.update(community_metrics)
if self.verbose > 0:
print("\nConfig")
print("-------\n")
for f in graph_fieldnames[:8]:
print("{}: {}".format(f, graph_metrics[f]))
print("\nMetrics")
print("-------\n")
for f in graph_fieldnames[8:]:
print("{}: {}".format(f, graph_metrics[f]))
# write metrics to CSV
csv_file = os.path.join(self.OUTPUT_DIRECTORY, "metrics.csv")
utils.write_metrics_csv(csv_file, graph_fieldnames, graph_metrics)