{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "67ce1e0d",
   "metadata": {},
   "source": [
    "**Computational Tools for Data Science, Fall 2024, DTU**\n",
    "\n",
    "# [Solution] Week 7: Mining social network graphs\n",
    "\n",
    "## Exercise 1: Divisive clustering via Girvan–Newman\n",
    "\n",
    "Implement a divisive hierarchical clustering algorithm via the Girvan–Newman method and\n",
    "compute modularity scores. \n",
    "\n",
    "Hence, you should implement the following parts:\n",
    "1. Compute the betweenness centrality for every edge of a graph.\n",
    "2. Implement a divisive hierarchical clustering algorithm based on removing edges with highest betweenness centrality and considering connected components as clusters.\n",
    "3. Compute modularity for a clustering of a graph.\n",
    "\n",
    "Test your implementations on the Karate-Club graph, found in `nx.karate_club_graph()`.\n",
    "\n",
    "Compare your implementations with the ones from networkx :\n",
    "- networkx.algorithms.centrality.edge betweenness centrality\n",
    "- networkx.algorithms.community.girvan newman\n",
    "- networkx.algorithms.community.modularity\n",
    "\n",
    "Use `matplotlib` to visualise the communities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e59a46a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b42150c9",
   "metadata": {},
   "source": [
    "# Using Karate Club\n",
    "G = nx.karate_club_graph()\n",
    "n, m = len(G.nodes()), len(G.edges())\n",
    "print('Nb nodes: n =', n)\n",
    "print('Nb edges: m =', m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5b2c7891",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using example from the slides of the lecture\n",
    "G_example = nx.Graph()\n",
    "\n",
    "all_nodes = ['A','B','C','D','E','F','G','H']\n",
    "G_example.add_nodes_from(all_nodes)\n",
    "\n",
    "all_edges = [\n",
    "    ('E','D'),('E','F'),\n",
    "    ('F','G'),('D','G'),('D','B'),('B','A'),('B','C'),('A','H'),\n",
    "    ('D','F'),('A','C')\n",
    "]\n",
    "G_example.add_edges_from(all_edges)\n",
    "\n",
    "G_example = G_example.to_undirected()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a16c02d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def step1(G, root):\n",
    "    \"\"\"\n",
    "       Perform Breadth-First Search to get all shortest paths from the root in given graph G\n",
    "       G: networkx graph\n",
    "       root: node from G to consider as root\n",
    "    \"\"\"\n",
    "    # List to keep track of visited nodes\n",
    "    visited, queue = [], []\n",
    "    # Initialize shortest paths\n",
    "    shortest_paths_dict = {}\n",
    "    \n",
    "    visited.append(root)\n",
    "    queue.append((root, [root]))\n",
    "\n",
    "    while queue:\n",
    "        s, path = queue.pop(0)\n",
    "\n",
    "        for neighbour in list(G.neighbors(s)):\n",
    "            if neighbour != root:\n",
    "                new_path = path + [neighbour]\n",
    "                if neighbour not in visited:\n",
    "                    visited.append(neighbour)\n",
    "                    queue.append((neighbour, new_path))\n",
    "                    shortest_paths_dict[neighbour] = [new_path]\n",
    "                else:\n",
    "                    if len(new_path) == len(shortest_paths_dict[neighbour][0]):\n",
    "                        shortest_paths_dict[neighbour].append(new_path)\n",
    "\n",
    "    return shortest_paths_dict"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4aecb2b4",
   "metadata": {},
   "source": [
    "ex_shortest_paths_dict = step1(G_example, 'E')\n",
    "ex_shortest_paths_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b0fe726e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def step2(G, shortest_paths_dict):\n",
    "    l2 = {}\n",
    "    for v in list(G.nodes()):\n",
    "        if v in list(shortest_paths_dict.keys()):\n",
    "            l2[v] = len(shortest_paths_dict[v])\n",
    "        else:\n",
    "            l2[v]=0\n",
    "    return l2"
   ]
  },
  {
   "cell_type": "raw",
   "id": "e79ce659",
   "metadata": {},
   "source": [
    "ex_l2 = step2(G_example, ex_shortest_paths_dict)\n",
    "ex_l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "bc8c8572",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_shortest_r2y_paths_using_e(all_paths, e):\n",
    "    result = []\n",
    "    start, end = e\n",
    "    for aPath in all_paths:\n",
    "        one_way = ''.join([str(a) for a in [start, end]]) in ''.join([str(a) for a in aPath])\n",
    "        reverse_way = ''.join([str(a) for a in [end, start]]) in ''.join([str(a) for a in aPath])\n",
    "        if one_way or reverse_way:\n",
    "            result.append(aPath)\n",
    "    return result\n",
    "\n",
    "def step3(G, shortest_paths_dict, l2):\n",
    "    b_r = []\n",
    "    for start_node, end_node in list(G.edges()):\n",
    "        list_to_sum = []\n",
    "        for y in list(G.nodes()):\n",
    "            if y in list(shortest_paths_dict.keys()):\n",
    "                all_shortest_r2y_paths = shortest_paths_dict[y]\n",
    "                all_shortest_r2y_using_e = find_shortest_r2y_paths_using_e(all_shortest_r2y_paths, [start_node, end_node])\n",
    "                list_to_sum.append(len(all_shortest_r2y_using_e)/len(all_shortest_r2y_paths))\n",
    "                # print((start_node, end_node), y, all_shortest_r2y_paths,all_shortest_r2y_using_e, list_to_sum)\n",
    "        b_r.append([[start_node, end_node], sum(list_to_sum)])\n",
    "    return b_r"
   ]
  },
  {
   "cell_type": "raw",
   "id": "53bbf1e0",
   "metadata": {},
   "source": [
    "b_r_ex = step3(G_example, ex_shortest_paths_dict, ex_l2)\n",
    "b_r_ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "261a857f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute final betweeness\n",
    "def edge_betweeness(G, e):\n",
    "    start, end = e\n",
    "    to_sum = []\n",
    "    for r in list(G.nodes()):\n",
    "        # step 1\n",
    "        shortest_paths_dict = step1(G, r)\n",
    "        # step 2\n",
    "        l2 = step2(G, shortest_paths_dict)\n",
    "        # step 3\n",
    "        b_r = step3(G, shortest_paths_dict, l2)\n",
    "        for edge_list, score in b_r:\n",
    "            if (edge_list == [start, end]) or (edge_list == [end, start]):\n",
    "                to_sum.append(score)\n",
    "    return 0.5 * sum(to_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2fbc704a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_edge_betweeness(G):\n",
    "    result = []\n",
    "    for start, end in list(G.edges()):\n",
    "        aScore = edge_betweeness(G, [start, end])\n",
    "        result.append([\n",
    "            [start, end],\n",
    "            aScore\n",
    "        ])\n",
    "    return result"
   ]
  },
  {
   "cell_type": "raw",
   "id": "559c1b62",
   "metadata": {},
   "source": [
    "all_edge_betweeness(G_example)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "56aee826",
   "metadata": {},
   "source": [
    "result = all_edge_betweeness(G_example)\n",
    "result.sort(key=lambda x:x[1], reverse=True)\n",
    "print(\"Edge with highest betweeness centrality:\", result[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4e37cc97",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bfs(graph):\n",
    "    \"\"\"SOURCE: https://www.educative.io/answers/how-to-implement-a-breadth-first-search-in-python\"\"\"\n",
    "    result = {}\n",
    "    for node in list(graph.nodes()):\n",
    "        visited = [] # List to keep track of visited nodes.\n",
    "        queue = []     #Initialize a queue\n",
    "        visited.append(node)\n",
    "        queue.append(node)\n",
    "\n",
    "        while queue:\n",
    "            s = queue.pop(0) \n",
    "\n",
    "            for neighbour in graph[s]:\n",
    "                if neighbour not in visited:\n",
    "                    visited.append(neighbour)\n",
    "                    queue.append(neighbour)\n",
    "        result[node] = set(visited)\n",
    "    return result\n",
    "\n",
    "def counting_clusters(bfs_result):\n",
    "    distinct_sets = []\n",
    "    for aSet in list(bfs_result.values()):\n",
    "        if not aSet in distinct_sets:\n",
    "            distinct_sets.append(aSet)\n",
    "    return distinct_sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "29d5188d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def clustering(G_original):\n",
    "    communities = {}\n",
    "    nb_iterations = 0\n",
    "    # create a copy of the G\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(G_original.nodes())\n",
    "    G.add_edges_from(G_original.edges())\n",
    "    G = G.to_undirected()\n",
    "    while (len(list(G.edges()))) > 0:\n",
    "        # compute betweeness centrality for all edges\n",
    "        b_c_edges = all_edge_betweeness(G)\n",
    "        b_c_edges.sort(key=lambda x:x[1], reverse=True)\n",
    "        # remove the edge with highest centrality\n",
    "        G.remove_edge(b_c_edges[0][0][0], b_c_edges[0][0][1])\n",
    "        # check the nb of sub graphs in G\n",
    "        clusters_result = bfs(G)\n",
    "        distinct_sets = counting_clusters(clusters_result)\n",
    "        # save sets\n",
    "        communities[nb_iterations] = distinct_sets\n",
    "        nb_iterations += 1\n",
    "    return communities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2203f97f",
   "metadata": {},
   "outputs": [],
   "source": [
    "communities = clustering(G_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bf5d9999",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: [{'A', 'B', 'C', 'H'}, {'D', 'E', 'F', 'G'}],\n",
       " 1: [{'A', 'B', 'C'}, {'D', 'E', 'F', 'G'}, {'H'}],\n",
       " 2: [{'A', 'B', 'C'}, {'D', 'E', 'F', 'G'}, {'H'}],\n",
       " 3: [{'A', 'B', 'C'}, {'D', 'F', 'G'}, {'E'}, {'H'}],\n",
       " 4: [{'A', 'B', 'C'}, {'D', 'F', 'G'}, {'E'}, {'H'}],\n",
       " 5: [{'A'}, {'B', 'C'}, {'D', 'F', 'G'}, {'E'}, {'H'}],\n",
       " 6: [{'A'}, {'B'}, {'C'}, {'D', 'F', 'G'}, {'E'}, {'H'}],\n",
       " 7: [{'A'}, {'B'}, {'C'}, {'D', 'F', 'G'}, {'E'}, {'H'}],\n",
       " 8: [{'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F', 'G'}, {'H'}],\n",
       " 9: [{'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'}, {'G'}, {'H'}]}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "communities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d72223aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Avw_indicator_function(G, v, w):\n",
    "    if (v,w) in list(G.edges()) or (w,v) in list(G.edges()):\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "def modularity(G, clusters_list):\n",
    "    Q = 0\n",
    "    m = len(list(G.edges()))\n",
    "    for aCommunity in clusters_list:\n",
    "        for v in list(aCommunity):\n",
    "            for w in list(aCommunity):\n",
    "                if v != w:\n",
    "                    new_term = Avw_indicator_function(G, v, w) - (G.degree(v)*G.degree(w))/(2*m)\n",
    "                    Q += new_term\n",
    "    return Q/(2*m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "76acb408",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_modularity_for_all_communities(G, all_communities):\n",
    "    result = []\n",
    "    for aCommunityRepartition in list(all_communities.values()):\n",
    "        aModularity = modularity(G, aCommunityRepartition)\n",
    "        result.append(\n",
    "            [aCommunityRepartition, aModularity]\n",
    "        )\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "245bf57b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: [[{'C', 'H', 'B', 'A'}, {'E', 'G', 'F', 'D'}], 0.5349999999999999]\n"
     ]
    }
   ],
   "source": [
    "all_clusters_with_modularity = compute_modularity_for_all_communities(G_example, communities)\n",
    "all_clusters_with_modularity.sort(key= lambda x:x[1], reverse=True)\n",
    "all_clusters_with_modularity\n",
    "print('Best:', all_clusters_with_modularity[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "80126db4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best_communities: [['C', 'H', 'B', 'A'], ['E', 'G', 'F', 'D']]\n",
      "- associated best_modularity: 0.5349999999999999\n"
     ]
    }
   ],
   "source": [
    "best_communities = [list(s) for s in all_clusters_with_modularity[0][0]]\n",
    "best_modularity = modularity(G_example, all_clusters_with_modularity[0][0])\n",
    "\n",
    "print('best_communities:', best_communities)\n",
    "print('- associated best_modularity:', best_modularity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d4988c83",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparing best communities:\n",
      "\t- My code: [['C', 'H', 'B', 'A'], ['E', 'G', 'F', 'D']]\n",
      "\t- NetworkX: (['A', 'B', 'C', 'H'], ['D', 'E', 'F', 'G'])\n",
      "\n",
      "Comparing Modularity:\n",
      "\t- My code: 0.5349999999999999\n",
      "\t- NetworkX: 0.395\n"
     ]
    }
   ],
   "source": [
    "# comparing with NetworkX\n",
    "\n",
    "nx_communities = nx.algorithms.centrality.edge_betweenness_centrality(G_example)\n",
    "\n",
    "nx_girvan_newman = nx.algorithms.community.centrality.girvan_newman(G_example)\n",
    "\n",
    "nx_best_community = tuple(sorted(c) for c in next(nx_girvan_newman))\n",
    "print('Comparing best communities:')\n",
    "print('\\t- My code:', best_communities)\n",
    "print('\\t- NetworkX:', nx_best_community)\n",
    "\n",
    "nx_modularity = nx.algorithms.community.quality.modularity(G_example, nx_best_community)\n",
    "print('\\nComparing Modularity:')\n",
    "print('\\t- My code:', best_modularity)\n",
    "print('\\t- NetworkX:', nx_modularity)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "012e67a7",
   "metadata": {},
   "source": [
    "## Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "967cc886",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install scikit-network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c3d7fe1",
   "metadata": {},
   "source": [
    "### Using sknetwork"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "eef3bfc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sknetwork.clustering import Louvain, get_modularity\n",
    "# from IPython.display import SVG\n",
    "# from sknetwork.data import karate_club\n",
    "# from sknetwork.hierarchy import LouvainHierarchy\n",
    "# from sknetwork.visualization import visualize_dendrogram\n",
    "\n",
    "\n",
    "# # Initializing the data (standalone script) - skip on solutions\n",
    "# graph = karate_club(metadata=True)\n",
    "# adjacency = graph.adjacency\n",
    "# position = graph.position\n",
    "\n",
    "\n",
    "# # Computing Louvain modularity\n",
    "# # https://scikit-network.readthedocs.io/en/latest/tutorials/clustering/louvain.html\n",
    "# louvain = Louvain()\n",
    "# louvain_partition = louvain.fit_predict(adjacency)\n",
    "# louvain_modularity = get_modularity(adjacency, louvain_partition)\n",
    "\n",
    "\n",
    "# print(f'\\t- Louvain modularity: {louvain_modularity}')\n",
    "\n",
    "\n",
    "# # Visualize the hierarchy\n",
    "# # https://scikit-network.readthedocs.io/en/latest/tutorials/hierarchy/louvain_recursion.html\n",
    "# louvain_hierarchy = LouvainHierarchy()\n",
    "# dendrogram = louvain_hierarchy.fit_predict(adjacency)\n",
    "# image = visualize_dendrogram(dendrogram)\n",
    "# SVG(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eae7d34",
   "metadata": {},
   "source": [
    "### Using Networkx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4b8b046a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modularity for Louvain: 0.4266224396094526\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "from networkx.algorithms.community import louvain_communities\n",
    "from networkx.algorithms.community.quality import modularity\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.cluster.hierarchy import dendrogram, linkage\n",
    "import numpy as np\n",
    "\n",
    "# Load the Karate Club graph\n",
    "K = nx.karate_club_graph()\n",
    "# K = G_example\n",
    "\n",
    "# Apply the Louvain algorithm from NetworkX\n",
    "louvain_comm = louvain_communities(K, seed=42)\n",
    "\n",
    "# Compute modularity for Louvain clusters\n",
    "louvain_modularity = modularity(K, louvain_comm)\n",
    "print(f\"Modularity for Louvain: {louvain_modularity}\")\n",
    "\n",
    "# Prepare clusters for the dendrogram\n",
    "louvain_clusters = [list(community) for community in louvain_comm]\n",
    "flat_clusters = np.concatenate(louvain_clusters)\n",
    "\n",
    "# Ensure all items in flat_clusters are converted to floats and print correspondence\n",
    "flat_clusters_float = []\n",
    "for item in flat_clusters:\n",
    "    if isinstance(item, (np.int32, np.float32, np.int64, np.float64)):\n",
    "        flat_clusters_float.append(int(item))\n",
    "        # print(f\"Original: {item} -> Transformed: {float(item)}\")\n",
    "    else:\n",
    "        transformed_value = int(ord(item) - ord('A'))\n",
    "        flat_clusters_float.append(transformed_value)\n",
    "        print(f\"Original: {item} -> Transformed: {transformed_value} (ASCII code)\")\n",
    "\n",
    "flat_clusters_float = np.array(flat_clusters_float)\n",
    "\n",
    "# Create a linkage matrix for the dendrogram\n",
    "Z = linkage(flat_clusters_float.reshape(-1, 1), 'ward')\n",
    "\n",
    "# Plot the dendrogram\n",
    "plt.figure(figsize=(10, 7))\n",
    "dendrogram(Z)\n",
    "plt.title(\"Dendrogram for Louvain Clusters\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "14a31e72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67\n"
     ]
    }
   ],
   "source": [
    "print(ord('C'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51a6e680",
   "metadata": {},
   "source": [
    "\n",
    "### Comparison of Girvan–Newman and Louvain Algorithms\n",
    "\n",
    "The Girvan–Newman algorithm is a divisive hierarchical method based on removing edges with the highest betweenness centrality, while the Louvain algorithm is a modularity optimization-based algorithm. \n",
    "\n",
    "Below is a comparison based on modularity scores:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1755e778",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**Girvan-Newman Modularity**: 0.5349999999999999\n",
      "**Louvain Modularity**: 0.4266224396094526\n"
     ]
    }
   ],
   "source": [
    "print(f'**Girvan-Newman Modularity**: {best_modularity}')\n",
    "print(f'**Louvain Modularity**: {louvain_modularity}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e192539",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "\n",
    "Compute the eigenvalues of the Laplacian matrix L(G) of G.\n",
    "\n",
    "(To compute eigenvalues you could use numpy.linalg.eigvals (you should import numpy).)\n",
    "(If you use networkx, you could use networkx.linalg.laplacianmatrix to obtain the Laplacian\n",
    "matrix of G.)\n",
    "\n",
    "Derive a bipartition of G via the second smallest eigenvalue of L(G).\n",
    "\n",
    "Compare your result with SpectralClustering from sklearn.cluster for 2 clusters. Experiment\n",
    "with SpectralClustering, e.g. by using more clusters or running it on the Karate-club graph\n",
    "from networkx.karate club graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "81d0c15b-f572-4995-9952-73cf555b7e7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sklearn   : 1.4.1.post1\n",
      "scipy     : 1.13.0\n",
      "networkx  : 3.3\n",
      "numpy     : 1.26.4\n",
      "IPython   : 8.20.0\n",
      "matplotlib: 3.8.3\n",
      "sknetwork : 0.33.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import scipy\n",
    "import sklearn\n",
    "\n",
    "%load_ext watermark\n",
    "%watermark --iversions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de1345b3-267d-447b-a817-e4da60ae4567",
   "metadata": {},
   "source": [
    "**Consider the following graph G.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "a3f42868-3e5f-4e89-bac4-09899f5c7e11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = nx.cycle_graph(6)\n",
    "G.add_edges_from([(0,6), (6,1), (2,7), (7,3), (4,8), (8,5)])\n",
    "nx.draw(G,with_labels=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9d1eda5-1d97-441f-b6e6-3068c185f003",
   "metadata": {},
   "source": [
    "**Compute the eigenvalues of the Laplacian matrix L(G) of G.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1a2a3b79-086d-4010-8052-7970f4c011e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3, -1,  0,  0,  0, -1, -1,  0,  0],\n",
       "       [-1,  3, -1,  0,  0,  0, -1,  0,  0],\n",
       "       [ 0, -1,  3, -1,  0,  0,  0, -1,  0],\n",
       "       [ 0,  0, -1,  3, -1,  0,  0, -1,  0],\n",
       "       [ 0,  0,  0, -1,  3, -1,  0,  0, -1],\n",
       "       [-1,  0,  0,  0, -1,  3,  0,  0, -1],\n",
       "       [-1, -1,  0,  0,  0,  0,  2,  0,  0],\n",
       "       [ 0,  0, -1, -1,  0,  0,  0,  2,  0],\n",
       "       [ 0,  0,  0,  0, -1, -1,  0,  0,  2]], dtype=int32)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make sure to update scipy to >1.8\n",
    "# https://github.com/pyg-team/pytorch_geometric/issues/4378\n",
    "laplacian = nx.linalg.laplacian_matrix(G).todense()\n",
    "laplacian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0eef3c3f-1522-42dc-bfff-5ba97a5ef106",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the eigenvalues and eigenvectors\n",
    "evals, evecs = np.linalg.eig(laplacian)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ae9da27-9a34-4839-b9a3-138ee79b2a22",
   "metadata": {},
   "source": [
    "**Derive a bipartition of G via the second smallest eigenvalue of L(G).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "f0462c59-d000-4253-8c9f-0d6b8dee75ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-0.02479811632008378,\n",
       " -0.2461046225049272,\n",
       " -0.3339828703304553,\n",
       " -0.1508382442635029,\n",
       " 0.35878098665053887,\n",
       " 0.3969428667684303,\n",
       " -0.20794274238703603,\n",
       " -0.37214475044834616,\n",
       " 0.5800874928353824]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# second smallest eigenvalue, also called the fiedler index\n",
    "fiedler_index = sorted(evals)[1]\n",
    "\n",
    "# crude way of finding the corresponding eigenvector\n",
    "i = 0\n",
    "for eigenval in evals:\n",
    "    if eigenval == fiedler_index:\n",
    "        idx = i\n",
    "    i += 1\n",
    "\n",
    "evec = evecs[:, idx].tolist()\n",
    "evec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "27ed7ccd-52a7-4189-8fae-2e0402cbad3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# negative eigenvector values correspond to one cluster and positive to another\n",
    "clusters = []\n",
    "for e in evec:\n",
    "    if e < 0:\n",
    "        clusters.append(0)\n",
    "    else:\n",
    "        clusters.append(1)\n",
    "\n",
    "nx.draw(G, with_labels=True, node_color=clusters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bc13a0f-a477-4231-b713-52b80bf8cda5",
   "metadata": {},
   "source": [
    "**Compare your result with SpectralClustering from sklearn.cluster for 2 clusters.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a4d71adb-0824-4922-a7ef-a75a3dfcc159",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\acoma\\AppData\\Roaming\\Python\\Python312\\site-packages\\sklearn\\cluster\\_kmeans.py:1446: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cluster import SpectralClustering\n",
    "\n",
    "adj_matrix = nx.to_numpy_array(G) \n",
    "node_list = list(G.nodes())\n",
    "\n",
    "#non-deterministic btw\n",
    "clusters = SpectralClustering(affinity='precomputed', n_clusters=2).fit_predict(adj_matrix)\n",
    "\n",
    "nx.draw(G, with_labels=True, node_color=clusters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "360c6452-cfd0-45bc-926c-a0bed9ef23d8",
   "metadata": {},
   "source": [
    "**Experiment\n",
    "with SpectralClustering, e.g. by using more clusters or running it on the Karate-club graph\n",
    "from networkx.karate club graph.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "bfc35d6a-12b9-45ef-a2e7-af5f41f22e14",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\acoma\\AppData\\Roaming\\Python\\Python312\\site-packages\\sklearn\\cluster\\_kmeans.py:1446: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clusters = SpectralClustering(affinity='precomputed', n_clusters=3).fit_predict(adj_matrix)\n",
    "\n",
    "nx.draw(G, with_labels=True, node_color=clusters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "bff35bba-8435-48c2-808e-5d9ec9151f32",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\acoma\\AppData\\Roaming\\Python\\Python312\\site-packages\\sklearn\\cluster\\_kmeans.py:1446: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "K = nx.karate_club_graph()\n",
    "\n",
    "adj_matrix = nx.to_numpy_array(K) \n",
    "node_list = list(K.nodes())\n",
    "\n",
    "clusters = SpectralClustering(affinity='precomputed', n_clusters=2).fit_predict(adj_matrix)\n",
    "\n",
    "nx.draw(K, node_color=clusters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f3b7e0d-b8dc-44a9-8149-e455de546d0b",
   "metadata": {},
   "source": [
    "### Helpful resources\n",
    "\n",
    "- https://en.wikipedia.org/wiki/Laplacian_matrix\n",
    "- https://math.stackexchange.com/questions/1407811/why-is-second-smallest-eigenvalue-and-the-corresponding-eigenvector-used-to-part\n",
    "- https://towardsdatascience.com/graph-laplacian-and-its-application-in-machine-learning-7d9aab021d16"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ML",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}