{ "cells": [ { "cell_type": "markdown", "id": "67ce1e0d", "metadata": {}, "source": [ "**Computational Tools for Data Science, Fall 2022, DTU**\n", "\n", "# [Solution] Week 8: 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": 149, "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": 272, "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": 245, "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": 246, "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": 247, "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": 248, "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": 249, "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": 250, "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": 273, "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": 274, "id": "2203f97f", "metadata": {}, "outputs": [], "source": [ "communities = clustering(G_example)" ] }, { "cell_type": "code", "execution_count": 275, "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": 275, "metadata": {}, "output_type": "execute_result" } ], "source": [ "communities" ] }, { "cell_type": "code", "execution_count": 301, "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": 323, "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": 329, "id": "245bf57b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best: [[{'C', 'A', 'H', 'B'}, {'G', 'F', 'D', 'E'}], 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": 331, "id": "80126db4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "best_communities: [['C', 'A', 'H', 'B'], ['G', 'F', 'D', 'E']]\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": 332, "id": "d4988c83", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Comparing best communities:\n", "\t- My code: [['C', 'A', 'H', 'B'], ['G', 'F', 'D', 'E']]\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": "3e192539", "metadata": {}, "source": [ "## Exercise 2\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": 1, "id": "81d0c15b-f572-4995-9952-73cf555b7e7e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "matplotlib: 3.5.2\n", "networkx : 2.8.4\n", "numpy : 1.21.5\n", "sklearn : 1.0.2\n", "scipy : 1.9.1\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": 2, "id": "a3f42868-3e5f-4e89-bac4-09899f5c7e11", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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": 3, "id": "1a2a3b79-086d-4010-8052-7970f4c011e3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ " compilation 20:4: FutureWarning: laplacian_matrix will return a scipy.sparse array instead of a matrix in Networkx 3.0.\n" ] }, { "data": { "text/plain": [ "matrix([[ 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]])" ] }, "execution_count": 3, "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": 4, "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": 5, "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": 5, "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": 6, "id": "27ed7ccd-52a7-4189-8fae-2e0402cbad3d", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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] < 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": 7, "id": "a4d71adb-0824-4922-a7ef-a75a3dfcc159", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/miniconda3/envs/datascience/lib/python3.10/site-packages/sklearn/utils/validation.py:593: FutureWarning: np.matrix usage is deprecated in 1.0 and will raise a TypeError in 1.2. Please convert to a numpy array with np.asarray. For more information see: https://numpy.org/doc/stable/reference/generated/numpy.matrix.html\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.cluster import SpectralClustering\n", "\n", "adj_matrix = nx.to_numpy_matrix(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": 8, "id": "bfc35d6a-12b9-45ef-a2e7-af5f41f22e14", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/miniconda3/envs/datascience/lib/python3.10/site-packages/sklearn/utils/validation.py:593: FutureWarning: np.matrix usage is deprecated in 1.0 and will raise a TypeError in 1.2. Please convert to a numpy array with np.asarray. For more information see: https://numpy.org/doc/stable/reference/generated/numpy.matrix.html\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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": 9, "id": "bff35bba-8435-48c2-808e-5d9ec9151f32", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/miniconda3/envs/datascience/lib/python3.10/site-packages/sklearn/utils/validation.py:593: FutureWarning: np.matrix usage is deprecated in 1.0 and will raise a TypeError in 1.2. Please convert to a numpy array with np.asarray. For more information see: https://numpy.org/doc/stable/reference/generated/numpy.matrix.html\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "K = nx.karate_club_graph()\n", "\n", "adj_matrix = nx.to_numpy_matrix(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": "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.8" } }, "nbformat": 4, "nbformat_minor": 5 }