www.allitebooks.com

Chapter 7
Next, we need to get the labels that indicate which connected component
each sample was placed in. We iterate over all the connected components,
noting in a dictionary which user belonged to which connected component.
The code is as follows:
label_dict = {}
for i, sub_graph in enumerate(sub_graphs):
for node in sub_graph.nodes():
label_dict[node] = i
Then we iterate over the nodes in the graph to get the label for each node in order.
We need to do this two-step process, as nodes are not clearly ordered within a graph
but they do maintain their order as long as no changes are made to the graph. What
this means is that, until we change the graph, we can call .nodes() on the graph to
get the same ordering. The code is as follows:
labels = np.array([label_dict[node] for node in G.nodes()])
Next the Silhouette Coefficient function takes a distance matrix, not a graph.
Addressing this is another two-step process. First, NetworkX provides a handy
function to_scipy_sparse_matrix, which returns the graph in a matrix format
that we can use:
X = nx.to_scipy_sparse_matrix(G).todense()
The Silhouette Coefficient implementation in scikit-learn, at the time of writing,
doesn't support sparse matrices. For this reason, we need to call the todense()
function. Typically, this is a bad idea—sparse matrices are usually used because
the data typically shouldn't be in a dense format. In this case, it will be fine because
our dataset is relatively small; however, don't try this for larger datasets.
For evaluating sparse datasets, I recommended that you look
into V-Measure or Adjusted Mutual Information. These are
both implemented in scikit-learn, but they have very different
parameters for performing their evaluation.
However, the values are based on our weights, which are a similarity and not a
distance. For a distance, higher values indicate more difference. We can convert
from similarity to distance by subtracting the value from the maximum possible
value, which for our weights was 1:
X = 1 - X
[ 157 ]