From d681d629aea488f13d05265ca28ec6dffe66b107 Mon Sep 17 00:00:00 2001 From: YY Ahn Date: Tue, 20 Feb 2024 17:39:43 -0500 Subject: [PATCH] communities --- docs/m07-communities/class.md | 6 + docs/m07-communities/lab07-link.ipynb | 279 ++++++++++++++++++++++++ docs/m07-communities/lab07.ipynb | 295 ++++++++++++++++++++++++++ mkdocs.yml | 2 + 4 files changed, 582 insertions(+) create mode 100644 docs/m07-communities/class.md create mode 100644 docs/m07-communities/lab07-link.ipynb create mode 100644 docs/m07-communities/lab07.ipynb diff --git a/docs/m07-communities/class.md b/docs/m07-communities/class.md new file mode 100644 index 0000000..602d479 --- /dev/null +++ b/docs/m07-communities/class.md @@ -0,0 +1,6 @@ +Probably the most basic way to quantify network community structure is in terms of categorical homophily. + + +This paper overviews multiple perspectives for community detection. + +- M. T. Schaub et al., [The many facets of community detection in complex networks](https://appliednetsci.springeropen.com/articles/10.1007/s41109-017-0023-6), Applied Network Science 2:4 (2017) https://doi.org/10.1007/s41109-017-0023-6 diff --git a/docs/m07-communities/lab07-link.ipynb b/docs/m07-communities/lab07-link.ipynb new file mode 100644 index 0000000..90706f3 --- /dev/null +++ b/docs/m07-communities/lab07-link.ipynb @@ -0,0 +1,279 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + "
\n", + " Run in Google Colab\n", + " \n", + " View on Github\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Link communities\n", + "For this assignment we will take a look at link communities and how they differ from node communities. In order to do this we will use the algorithm discussed in the reading (\"Link communities reveal multiscale complexity in networks\") and link community video from canvas.\n", + "\n", + "A small python module has been prepared that will allow you to use the link community algorithm with Anaconda and Python 3.5. To install the module you want to open a terminal or shell and use:\n", + "\n", + "```\n", + "pip install git+https://github.com/Nathaniel-Rodriguez/linkcom.git\n", + "```\n", + "\n", + "This will install the package locally in your Anaconda site-packages directory (the same place where the `conda` command would install new packages). Make sure you have [git](https://git-scm.com/) installed first. If you are using Windows you will need to use the Anaconda command prompt when using pip, so that it adds the package to Anaconda. If you have trouble installing the package you can just unpack the zip file from the [github repository](https://github.com/Nathaniel-Rodriguez/linkcom/tree/master/linkcom) and put the linkcom folder in your working directory.\n", + "\n", + "To use the package you can do:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import linkcom" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code has been adapted so that it will work with networkx graphs. The link communities algorithm requires simple undirected graphs to use. This means there can't be any self-loops or parallel edges. However, you can use weighted graphs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# First lets import networkx\n", + "import networkx as nx\n", + "\n", + "# And generate a new graph\n", + "my_graph = nx.erdos_renyi_graph(100, 0.1)\n", + "\n", + "# We need to make sure this is a graph of type Graph\n", + "print(type(my_graph).__name__)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the graph you load in isn't of type Graph (it maybe a Multigraph or DiGraph), it is easy to convert it to one:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_graph = nx.Graph(my_graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using linkcom\n", + "Now lets call the `cluster` method in `linkcom` to cluster the links of the graph. The `cluster` method takes several optional arguments:\n", + "\n", + "```\n", + "linkcom.cluster(nx_graph, threshold=None, is_weighted=False, weight_key='weight', dendro_flag=False, to_file=False, basename=\"clustering\", delimiter='\\t')\n", + "```\n", + "\n", + "`Threshold`: sets the cut-off for the dendrogram.\n", + "\n", + "`is_weighted`: can be `True` or `False` depending upon whether the graph has weights or not. Set this to `True` if the graph is weighted.\n", + "\n", + "`weight_key`: specifies what attribute the edges have that has weight values. In networkx it is convention that this key be set to `weight`. Most functions in networkx will assume this is the key. This is also the default value for the cluster method.\n", + "\n", + "`dendro_flag`: specifies whether to return the dendrogram (only applicable if the graph is unweighted and no threshold is given).\n", + "\n", + "`to_file`: specifies whether to write the outputs to file. Several files will be written and given names based on `basename` with elements separated by `delimiter`. \n", + "\n", + "These outputs will be written to file:\n", + "\n", + "```\n", + "Three text files with extensions .edge2comm.txt, .comm2edges.txt,\n", + "and .comm2nodes.txt store the communities.\n", + "\n", + "edge2comm, an edge on each line followed by the community\n", + "id (cid) of the edge's link comm:\n", + "node_i node_j cid \n", + "\n", + "comm2edges, a list of edges representing one community per line:\n", + "cid ni,nj nx,ny [...] \n", + "\n", + "comm2nodes, a list of nodes representing one community per line:\n", + "cid ni nj [...] \n", + "\n", + "The output filename contains the threshold at which the dendrogram\n", + "was cut, if applicable, or the threshold where the maximum\n", + "partition density was found, and the value of the partition \n", + "density.\n", + "\n", + "If no threshold was given to cut the dendrogram, a file ending with\n", + "'_thr_D.txt' is generated, containing the partition density as a\n", + "function of clustering threshold.\n", + "\n", + "If the dendrogram option was given, two files are generated. One with\n", + "'.cid2edge.txt' records the id of each edge and the other one with\n", + "'.linkage.txt' stores the linkage structure of the hierarchical \n", + "clustering. In the linkage file, the edge in the first column is \n", + "merged with the one in the second at the similarity value in the \n", + "third column.\n", + "```\n", + "\n", + "The cluster method will return a tuple with different elements:\n", + "\n", + " If no threshold is given, then a tuple is returned with: (dict) dictionary with keys=edges and values=community membership, (float) best similarity, (float) best partition density, (list) partition density list.\n", + "\n", + " If dendro_flag is given (only applicable if no threshold), then a tuple is returned with: (dict) dictionary with keys=edges and values=community membership, (float) best similarity, (float) best partition density, (list) partition density list, (dict) keys=edges and values=community membership for original, (list) dendrogram.\n", + "\n", + " If threshold is given a tuple is returned with: (dict) dictionary with keys=edges and values=community membership, partition density at threshold.\n", + "\n", + "You will mostly just be interested in using the dictionary which contains the community assignment data, which is always the first element of the tuple. Lets do a short example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "e2c, S, D, Dlist = linkcom.cluster(my_graph)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Dlist" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we print `e2c` we will see that each edge has a community membership:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(e2c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since this is a random graph, we expect there not to be any meaningful communities, and indeed they are all labelled `56` (the community ID), so there doesn't appear to be any link communities in the graph.\n", + "\n", + "We can now readily take our results and put them back into our graph so that it can be saved and viewed in Gephi. We can do this using the [`set_edge_attributes`](https://networkx.github.io/documentation/stable/reference/generated/networkx.classes.function.set_edge_attributes.html?highlight=set_edge_attributes#networkx.classes.function.set_edge_attributes) function in networkx. It works just like the `set_node_attributes` function from previuos assignments, but with edges instead:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Put the link communities into the graph\n", + "# Note this function's syntax depends on the networkx version.\n", + "# If you use networkx 1.9 and below this line should be\n", + "# nx.set_edge_attributes(my_graph, \"linkcom\", e2c)\n", + "nx.set_edge_attributes(my_graph, e2c, \"linkcom\")\n", + "\n", + "# Save the graph to file\n", + "nx.write_gexf(my_graph, \"my_graph.gexf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now if we were to open the graph in Gephi we should be able to use the link communities to color the graph edges. In Gephi you may need to click the little attribute type button so that edge attributes are set to [ranked rather than numeric](https://gephi.org/tutorials/gephi-tutorial-quick_start.pdf). This is because we want to color the edges according to their membership and not with a gradient. Additionally, in order to keep the edge colors when saving the graph you will need to make sure the edge color in the Preview tab is set to `original`. Lastly, since you will be looking at link communities (which determine the node membership in link clustering) it will be helpful to increase the size of the edges in Gephi so the colors are more visible and so you can detect nodes that belong to multiple communities.\n", + "\n", + "## The task\n", + "You can choose one from these two datasets:\n", + "\n", + "One is the NetSci collaboration graph. The nodes of the graph are people and links are formed between people who co-author a scientific paper together in network science. You can download it from [here](http://vlado.fmf.uni-lj.si/pub/networks/data/collab/netscience.htm). Hint: load with `read_pajek`.\n", + "\n", + "The graph has ~1500 nodes and is partly disconnected. If you have difficulty working with the full graph or trouble loading it into Gephi, you can use the largest connected component (which only has about 350 nodes). The largest connected component of a graph can be returned from networkx using:\n", + "\n", + "```\n", + "largest_component = my_graph.subgraph(sorted(nx.connected_components(my_graph), key=len, reverse=True)[0])\n", + "```\n", + "\n", + "Most of the interesting stuff is happening around this component anyway. So you don't lose much except for the scientists and groups that decided to work alone.\n", + "\n", + "Another option is the word association graph. Download: [here](https://www.dropbox.com/s/oky3cwwtwy1dfs0/word.edgelist?dl=0)\n", + "\n", + "Follow these steps for the assignment:\n", + "\n", + "Gephi users:\n", + "1. Load the graph and run the link communities clustering algorithm on it using linkcom module. You can follow the above-mentioned instructions to use the linkcom module.\n", + "2. Save the link communities to the graph and save the graph to file.\n", + "3. In Gephi choose a good layout for the graph.\n", + "4. Run the modularity command to generate communities for the nodes.\n", + "5. Color the edges according to the link communities and the nodes according to the communities found by Gephi. Remember to take care in choosing the resolution parameter.\n", + "6. How well does link clustering do at detecting community structure? How well does Gephi's node modularity do at detecting community structure? What do you think the communities represent? You can just provide a qualitative observation based on your intuition.\n", + "7. What are the similarities and differences between the communities detected by either algorithm?\n", + "8. i. (For NetSci Collaboration Graph) Which authors have a prominent position in multiple communities? What do you think these author's roles are?
\n", + " ii. (For Word Association Graph) Which words have a prominent position in multiple communities? What do you think these words' roles are?\n", + "9. What other features do you notice about the graph that are captured with overlaping communities?\n", + "10. Save your visualization to file.\n", + "11. Once complete, submit a PDF document to Canvas that contains your responses and your graph visualization (since this is a larger graph feel free to crop the figure so that it only includes parts relevant to your responses).\n", + "\n", + "Cytoscape users:\n", + "1. Instead of the code above, you may want to write the edges and their attributes into a `.csv` (comma seperated values) file. In Cytoscape, use \"File\" -> \"Import\" -> \"Table from file\".\n", + "2. Follow the instructions above. You can use some community detection plugins of your choice. It is ok if some details are different." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/m07-communities/lab07.ipynb b/docs/m07-communities/lab07.ipynb new file mode 100644 index 0000000..f54e8a3 --- /dev/null +++ b/docs/m07-communities/lab07.ipynb @@ -0,0 +1,295 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Community detection\n", + "\n", + "\n", + "\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intuition\n", + "\n", + "First, let's think about the extreme case. If a network consists of multiple groups that are barely connected, then we can expect that the network can be easily divided into these groups. Let's consider a \"barbell\" network, which consists of two complete graphs connected by a single edge. " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import networkx as nx\n", + "\n", + "options = {\n", + " 'node_size': 100,\n", + " 'width': 0.5,\n", + " 'with_labels': False,\n", + "}\n", + "\n", + "G = nx.barbell_graph(10, 0)\n", + "nx.draw(G, node_color=\"black\", **options)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An obvious way to identify the two groups is to \"cut\" the edge that connects the two complete graphs. This is the intuition behind the \"Girvan-Newman\" algorithm, which is one of the earliest and most intuitive community detection algorithms.\n", + "\n", + "This algorithm calculates the \"betweenness\" of each edge. Then, it removes the edge with the highest betweenness, and recalculates the betweenness of the edges. This process is repeated to break the network into smaller pieces. While doing so, we can measure the modularity of the network, which tells us when to stop the process.\n", + "\n", + "In this extreme case, there is a clear \"cut\" that separates the two groups. And that's exactly what the Girvan-Newman algorithm finds. \n", + "\n", + "**Q: can you apply the Girvan-Newman algorithm to the barbell network?**" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16, 17, 18, 19])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# YOUR SOLUTION HERE\n", + "\n", + "communities" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "node_color = [0] * len(G)\n", + "for i, comm in enumerate(communities):\n", + " for node in comm:\n", + " node_color[node] = i\n", + "\n", + "nx.draw(G, node_color=node_color, **options)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, in reality, the network is not as clear-cut as the barbell network and the Girvan-Newman algorithm does not usually work well. It tends to destroy the network structure _before_ finding the communities. Moreover, the algorithm is computationally expensive, as it requires calculating the betweenness of all edges (one of the slowest operations in network analysis). \n", + "\n", + "So we don't really use it anymore in practice. 😅" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Divisive vs. Agglomerative \n", + "\n", + "The Girvan-Newman algorithm is an example of a \"divisive\" community detection algorithm. It starts with the entire network and breaks it into smaller pieces until we find the communities. Another way to think about community detection is to start with individual nodes and \"merge\" them into communities. This is called \"agglomerative\" community detection. (statistical inference is a more principled approach and we will talk about it later.)\n", + "\n", + "In divisive algorithms, we focus on the boundary between communities. In agglomerative algorithms, we focus on the similarity or 'cohesion' within communities.\n", + "\n", + "## Planted Partition Model\n", + "\n", + "Let's think about the \"barbell\" network again. Instead of saying that there should be only one edge that connects the two complete graphs, we can allow more edges to connect the two communities. We can also make each community not a complete graph, but just a dense subgraph. Both of these changes make the network less clear-cut. \n", + "\n", + "This is a special case of \"stoachastic block model\" (SBM), and commonly referred to as the \"planted partition model\" because we \"plant\" the \"partition\" (community structure) into the network. In this model, we set the probability of an edge between nodes in the same community ($p_{in}$) to be higher than the probability of an edge between nodes in different communities ($p_{out}$).\n", + "\n", + "**Q: make a planted partition model with 2 communities with the following parameters.**" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# make a planted partition graph with 2 communities, each with 15 nodes. \n", + "# use p_in = 0.7 and p_out = 0.05\n", + "\n", + "# YOUR SOLUTION HERE\n", + "\n", + "nx.draw(G_planted, node_color=\"black\", **options)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Louvain algorithm\n", + "\n", + "Given a network, you can come up with many ways to cluster the nodes. For instance, you can define similarity between nodes by calculating neighbor overlap. Once you have the similarity matrix, you can use a clustering algorithm to find the communities. However, when similarity measure is not tied to what we want to find (communities), they tend not to work well in practice. \n", + "\n", + "The most successful (heuristic) algorithms tend to see this problem as an optimization problem (maximizing modularity or similar objective functions like map equation) and use heuristics to find the communities. \n", + "\n", + "As you learn from the course modules, the two best examples, also the most widely used community detection algorithms, are the Louvain algorithm and the Infomap algorithm. Here, let's play with the Louvain algorithm: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.community.louvain.louvain_communities.html#networkx.algorithms.community.louvain.louvain_communities\n", + "\n", + "**Q: apply the Louvain algorithm to the planted partition model and visualize the communities.**" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# YOUR SOLUTION HERE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zachary's Karate Club\n", + "\n", + "Now, let's look at a real-world network. Zachary's Karate Club is the most famous social network data in community detection literature. Since Girvan and Newman used this network to illustrate their algorithm, it has been widely used to showcase community detection algorithms. The network is very small and easy to grasp, although it is not necessarily representative of real-world networks with community structure, it has been used as a go-to example for community detection algorithms. Actually, it is so over-used that it became the subject of an in-joke in the network science community. \n", + "\n", + "![](https://64.media.tumblr.com/d8b21a98efb7bdcdc2afdff163009474/tumblr_mmg1bek2lP1sqr43do2_r1_400.png)\n", + "\n", + "There is a \"club\" called \"The Zachary’s Karate Club CLUB\" and an accompanying, traveling trophy: https://networkkarate.tumblr.com/ (you can also find me here...)\n", + "\n", + "The trophy holder should bring the trophy to the conferences and workshops, and then pass it to the person who shows the Zachary's Karate Club network in their presentation for the first time in the conference. 😂 \n", + "\n", + "For the honor of the club, let's try the Louvain algorithm on the Zachary's Karate Club network.\n", + "\n", + "**Q: apply the Louvain algorithm to the Zachary's Karate Club network and visualize the communities.**" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "G_karate = nx.karate_club_graph()\n", + "\n", + "# YOUR SOLUTION HERE\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not exactly the community structure we expected! 🙈 \n", + "\n", + "Finding the exact two communities from this network does not mean that the algorithm is good; not finding the two communities also does not mean that the algorithm is bad! What is important is that we need to be very clear about what we want to find and how we evaluate the algorithm.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Find some communities!\n", + "\n", + "Now, pick a real-world network and find communities from the network! Pick a network where you expect to see fairly clear community structure (and small). Apply any community detection algorithm you like (Louvain, Infomap, etc.) and visualize the communities with whatever tool that you like (NetworkX, Gephi, etc.). Discuss the result. Did it find the structure that you expected? If not, why do you think it didn't work? Does the network community correspond to some groups in the real world? Why? Why not?\n", + "\n", + "You can either use this notebook or attach a separate document (PDF) with the visualization." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "netsci-solutions-LnlMpkYR-py3.11", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/mkdocs.yml b/mkdocs.yml index 1aa38fc..98c81eb 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -97,5 +97,7 @@ nav: - m05-scalefree/lab05.ipynb - "Module 6: Centralities": - m06-centrality/lab06.ipynb + - "Module 7: Communites": + - m07-communities/lab07.ipynb - "Resources": - resources/index.md