From 75403e4cd8df090ea80e664859805f3a3354ed97 Mon Sep 17 00:00:00 2001
From: Ricardo Mendes <ricardolsmendes@gmail.com>
Date: Wed, 11 Oct 2023 23:34:55 -0300
Subject: [PATCH] docs: add didact examples for presentations (#7)

---
 data/samples/presentation-example.csv         |  13 +
 .../5_presentation-example.ipynb              | 533 ++++++++++++++++++
 2 files changed, 546 insertions(+)
 create mode 100644 data/samples/presentation-example.csv
 create mode 100644 social-network-analysis/5_presentation-example.ipynb

diff --git a/data/samples/presentation-example.csv b/data/samples/presentation-example.csv
new file mode 100644
index 0000000..670ab1e
--- /dev/null
+++ b/data/samples/presentation-example.csv
@@ -0,0 +1,13 @@
+A,B
+A,E
+B,C
+B,D
+C,D
+D,E
+E,F
+E,G
+F,H
+F,I
+F,J
+F,K
+J,K
diff --git a/social-network-analysis/5_presentation-example.ipynb b/social-network-analysis/5_presentation-example.ipynb
new file mode 100644
index 0000000..bb409c3
--- /dev/null
+++ b/social-network-analysis/5_presentation-example.ipynb
@@ -0,0 +1,533 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d8629d34",
+   "metadata": {},
+   "source": [
+    "# Social Network Analysis applied to Data Warehouses\n",
+    "\n",
+    "## 5. Presentation examples based on a sample dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e482941",
+   "metadata": {},
+   "source": [
+    "### 5.1. Import dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "33fdb2b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import itertools\n",
+    "from typing import Dict, List, Tuple\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import networkx as nx\n",
+    "from networkx.classes.graph import Graph\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ca42e6f",
+   "metadata": {},
+   "source": [
+    "### 5.2. Utility functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a70be649",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_graph_from_csv(file: str) -> Graph:\n",
+    "    return nx.read_edgelist(file, delimiter=\",\", create_using=nx.DiGraph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6cb243bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def format_graph_info(graph_id: str, graph: Graph) -> str:\n",
+    "    return (\n",
+    "        f\"{graph_id.upper()} GRAPH INFO:\\n\"\n",
+    "        f\"  Number of nodes: {nx.number_of_nodes(graph)}\\n\"\n",
+    "        f\"  Number of edges: {nx.number_of_edges(graph)}\\n\"\n",
+    "        f\"  Density: {nx.density(graph)}\\n\"\n",
+    "        f\"  Average clustering coefficient: {nx.average_clustering(graph)}\\n\"\n",
+    "        f\"  Transitivity: {nx.transitivity(graph)}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "16087b81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_out_degree_based_network(graph: Graph) -> None:\n",
+    "    highest_degree = max([degree for _, degree in graph.out_degree])\n",
+    "    scaling_factor = 3500 / highest_degree\n",
+    "\n",
+    "    normalized_node_params = [\n",
+    "        (degree or 0.05) * scaling_factor for _, degree in graph.out_degree\n",
+    "    ]\n",
+    "\n",
+    "    plt.figure(figsize=(8, 5))\n",
+    "    nx.draw_networkx(\n",
+    "        graph,\n",
+    "        pos=nx.spring_layout(graph),\n",
+    "        edge_color=\"dimgray\",\n",
+    "        node_color=normalized_node_params,\n",
+    "        node_size=normalized_node_params,\n",
+    "    )\n",
+    "    plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9939e02b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def group_nodes_by_out_degree(\n",
+    "    graph: Graph, highest_first: bool = True\n",
+    ") -> Dict[int, List[str]]:\n",
+    "    degrees = [degree for _, degree in graph.out_degree]\n",
+    "    unique_degrees = sorted(np.unique(degrees), reverse=highest_first)\n",
+    "    degrees_dict = {}\n",
+    "    for unique_degree in unique_degrees:\n",
+    "        degrees_dict[int(unique_degree)] = sorted(\n",
+    "            [node for node, degree in graph.out_degree if degree == unique_degree]\n",
+    "        )\n",
+    "    return degrees_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "45d509d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_out_degree_critical_nodes_for_count(\n",
+    "    graph: Graph, target_node_count\n",
+    ") -> Tuple[Dict[int, List[str]], float]:\n",
+    "    node_count = 0\n",
+    "    degree_groups = group_nodes_by_out_degree(graph)\n",
+    "    degree_sum = sum([degree for _, degree in graph.out_degree])\n",
+    "\n",
+    "    group_count = 0\n",
+    "    while node_count < target_node_count:\n",
+    "        group_count += 1\n",
+    "        highest_degrees = dict(itertools.islice(degree_groups.items(), group_count))\n",
+    "        node_count = sum([len(nodes) for _, nodes in highest_degrees.items()])\n",
+    "\n",
+    "    highest_degree_sum = sum(\n",
+    "        [degree * len(nodes) for degree, nodes in highest_degrees.items()]\n",
+    "    )\n",
+    "    groups_degree_ratio = highest_degree_sum / degree_sum * 100\n",
+    "    print(\n",
+    "        f\"{group_count}-critical-groups node count: {node_count}\\n\"\n",
+    "        f\"{group_count}-critical-groups/total out-degree ratio:\"\n",
+    "        f\" {groups_degree_ratio:.0f}% ({highest_degree_sum}/{degree_sum})\"\n",
+    "    )\n",
+    "\n",
+    "    return highest_degrees, node_count"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "4ab1e3ef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_betweenness_centrality_based_network(graph: Graph) -> None:\n",
+    "    bet_cent = nx.betweenness_centrality(graph, normalized=False)\n",
+    "\n",
+    "    lowest_non_zero_bet_cent = min(\n",
+    "        [betweenness for _, betweenness in bet_cent.items() if betweenness > 0]\n",
+    "    )\n",
+    "    highest_bet_cent = max([betweenness for _, betweenness in bet_cent.items()])\n",
+    "    scaling_factor = 3500 / highest_bet_cent\n",
+    "\n",
+    "    normalized_node_params = [\n",
+    "        (betweenness or (lowest_non_zero_bet_cent / 5)) * scaling_factor\n",
+    "        for _, betweenness in bet_cent.items()\n",
+    "    ]\n",
+    "\n",
+    "    plt.figure(figsize=(8, 5))\n",
+    "    nx.draw_networkx(\n",
+    "        graph,\n",
+    "        pos=nx.spring_layout(graph),\n",
+    "        edge_color=\"dimgray\",\n",
+    "        node_color=normalized_node_params,\n",
+    "        node_size=normalized_node_params,\n",
+    "    )\n",
+    "    plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "076586f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_betweenness_centrality_list(bet_cent: Dict[str, float]) -> List[float]:\n",
+    "    return [betweenness for _, betweenness in bet_cent.items()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4bc130b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def group_nodes_by_betweenness_centrality(\n",
+    "    bet_cent: Dict[str, float], highest_first: bool = True\n",
+    ") -> Dict[float, List[str]]:\n",
+    "    bet_cent_list = get_betweenness_centrality_list(bet_cent)\n",
+    "    unique_bet_cent = sorted(np.unique(bet_cent_list), reverse=highest_first)\n",
+    "    sorted_bet_cent_dict = {}\n",
+    "    for value in unique_bet_cent:\n",
+    "        sorted_bet_cent_dict[value] = sorted(\n",
+    "            [node for node, bc in bet_cent.items() if bc == value]\n",
+    "        )\n",
+    "    return sorted_bet_cent_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "07dcf69a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_betweenness_centrality_critical_nodes_for_count(\n",
+    "    graph: Graph, target_node_count\n",
+    ") -> Tuple[Dict[int, List[str]], float]:\n",
+    "    node_count = 0\n",
+    "    bet_cent = nx.betweenness_centrality(graph, normalized=False)\n",
+    "    bc_groups = group_nodes_by_betweenness_centrality(bet_cent)\n",
+    "\n",
+    "    group_count = 0\n",
+    "    while node_count < target_node_count:\n",
+    "        group_count += 1\n",
+    "        highest_bc = dict(itertools.islice(bc_groups.items(), group_count))\n",
+    "        node_count = sum([len(nodes) for _, nodes in highest_bc.items()])\n",
+    "\n",
+    "    print(f\"{group_count}-critical-groups node count: {node_count}\\n\")\n",
+    "\n",
+    "    return highest_bc, node_count"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "38cf8c65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_clustering_based_network(graph: Graph) -> None:\n",
+    "    clustering = nx.clustering(graph)\n",
+    "\n",
+    "    lowest_non_zero_clust_coef = min(\n",
+    "        clust_coef for _, clust_coef in clustering.items() if clust_coef > 0\n",
+    "    )\n",
+    "    highest_clust_coef = max(clust_coef for _, clust_coef in clustering.items())\n",
+    "    scaling_factor = 3500 / highest_clust_coef\n",
+    "\n",
+    "    normalized_node_params = [\n",
+    "        (0.5 - (clust_coef or (lowest_non_zero_clust_coef / 10))) * scaling_factor\n",
+    "        for _, clust_coef in clustering.items()\n",
+    "    ]\n",
+    "\n",
+    "    plt.figure(figsize=(8, 5))\n",
+    "    nx.draw_networkx(\n",
+    "        graph,\n",
+    "        pos=nx.spring_layout(graph),\n",
+    "        edge_color=\"dimgray\",\n",
+    "        node_color=normalized_node_params,\n",
+    "        node_size=normalized_node_params,\n",
+    "    )\n",
+    "    plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "4f3658f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_clustering_list(clustering: Dict[str, float]) -> List[float]:\n",
+    "    return [clust_coef for _, clust_coef in clustering.items()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "241f34d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def group_nodes_by_clustering(clustering: Dict[str, float]) -> Dict[float, List[str]]:\n",
+    "    clustering_list = get_clustering_list(clustering)\n",
+    "    unique_clustering = sorted(np.unique(clustering_list))\n",
+    "    sorted_clustering_dict = {}\n",
+    "    for value in unique_clustering:\n",
+    "        sorted_clustering_dict[value] = sorted(\n",
+    "            [node for node, cl in clustering.items() if cl == value]\n",
+    "        )\n",
+    "    return sorted_clustering_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "ebaad834",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_clustering_critical_nodes_for_count(\n",
+    "    graph: Graph, target_node_count\n",
+    ") -> Tuple[Dict[int, List[str]], float]:\n",
+    "    node_count = 0\n",
+    "    clustering = nx.clustering(graph)\n",
+    "    cl_groups = group_nodes_by_clustering(clustering)\n",
+    "\n",
+    "    group_count = 0\n",
+    "    while node_count < target_node_count:\n",
+    "        group_count += 1\n",
+    "        lowest_cl = dict(itertools.islice(cl_groups.items(), group_count))\n",
+    "        node_count = sum([len(nodes) for _, nodes in lowest_cl.items()])\n",
+    "\n",
+    "    print(f\"{group_count}-critical-groups node count: {node_count}\\n\")\n",
+    "\n",
+    "    return lowest_cl, node_count"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fca69287",
+   "metadata": {},
+   "source": [
+    "### 5.3. Load the sample dataset from CSV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "d55b4eee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PRESENTATION GRAPH INFO:\n",
+      "  Number of nodes: 11\n",
+      "  Number of edges: 13\n",
+      "  Density: 0.11818181818181818\n",
+      "  Average clustering coefficient: 0.1712121212121212\n",
+      "  Transitivity: 0.1111111111111111\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "sample_data_folder = \"../data/samples\"\n",
+    "\n",
+    "presentation_graph = load_graph_from_csv(\n",
+    "    f\"{sample_data_folder}/presentation-example.csv\"\n",
+    ")\n",
+    "print(f'{format_graph_info(\"presentation\", presentation_graph)}\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e363abb5",
+   "metadata": {},
+   "source": [
+    "### 5.4. Draw the networks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "5a6a2c2f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_out_degree_based_network(presentation_graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "a2502659",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4-critical-groups node count: 11\n",
+      "4-critical-groups/total out-degree ratio: 100% (13/13)\n",
+      "\n",
+      "{4: ['F'], 2: ['A', 'B', 'E'], 1: ['C', 'D', 'J'], 0: ['G', 'H', 'I', 'K']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "presentation_critical_groups, _ = get_out_degree_critical_nodes_for_count(\n",
+    "    presentation_graph, 10\n",
+    ")\n",
+    "print(f\"\\n{presentation_critical_groups}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "fea60aec",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_betweenness_centrality_based_network(presentation_graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "b0d96214",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5-critical-groups node count: 11\n",
+      "\n",
+      "\n",
+      "{24.0: ['E'], 20.0: ['F'], 14.0: ['D'], 2.0: ['B'], 0.0: ['A', 'C', 'G', 'H', 'I', 'J', 'K']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "presentation_critical_groups, _ = get_betweenness_centrality_critical_nodes_for_count(\n",
+    "    presentation_graph, 10\n",
+    ")\n",
+    "print(f\"\\n{presentation_critical_groups}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "f20bcf19",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_clustering_based_network(presentation_graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "22be1ce1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4-critical-groups node count: 11\n",
+      "\n",
+      "\n",
+      "{0.0: ['A', 'E', 'G', 'H', 'I'], 0.05: ['F'], 0.16666666666666666: ['B', 'D'], 0.5: ['C', 'J', 'K']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "presentation_critical_groups, _ = get_clustering_critical_nodes_for_count(\n",
+    "    presentation_graph, 10\n",
+    ")\n",
+    "print(f\"\\n{presentation_critical_groups}\")"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}