02_RicciCurvature.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wXEJ_w9haYpF",
        "outputId": "30523285-7a24-4c00-e837-9a52dc3d5bd8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting GraphRicciCurvature\n",
            "  Downloading GraphRicciCurvature-0.5.3.1-py3-none-any.whl (23 kB)\n",
            "Collecting pot>=0.8.0\n",
            "  Downloading POT-0.8.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (664 kB)\n",
            "\u001b[K     |████████████████████████████████| 664 kB 27.0 MB/s \n",
            "\u001b[?25hRequirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from GraphRicciCurvature) (21.3)\n",
            "Requirement already satisfied: python-louvain in /usr/local/lib/python3.7/dist-packages (from GraphRicciCurvature) (0.16)\n",
            "Requirement already satisfied: cython in /usr/local/lib/python3.7/dist-packages (from GraphRicciCurvature) (0.29.30)\n",
            "Collecting networkit>=6.1\n",
            "  Downloading networkit-10.0.tar.gz (5.7 MB)\n",
            "\u001b[K     |████████████████████████████████| 5.7 MB 53.3 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from GraphRicciCurvature) (1.21.6)\n",
            "Requirement already satisfied: networkx>=2.0 in /usr/local/lib/python3.7/dist-packages (from GraphRicciCurvature) (2.6.3)\n",
            "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from GraphRicciCurvature) (1.4.1)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->GraphRicciCurvature) (3.0.9)\n",
            "Building wheels for collected packages: networkit\n",
            "  Building wheel for networkit (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for networkit: filename=networkit-10.0-cp37-cp37m-linux_x86_64.whl size=8166550 sha256=6572a77b106b4c7114e8f0965f50f302fdaffc2588303b775e08c7d33ba8c27d\n",
            "  Stored in directory: /root/.cache/pip/wheels/63/7a/29/82ad675434206a11470c7179c78d3f172ea2a6bc05cfb7391c\n",
            "Successfully built networkit\n",
            "Installing collected packages: pot, networkit, GraphRicciCurvature\n",
            "Successfully installed GraphRicciCurvature-0.5.3.1 networkit-10.0 pot-0.8.2\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (1.0.2)\n",
            "Requirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn) (1.4.1)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn) (3.1.0)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn) (1.1.0)\n",
            "Requirement already satisfied: numpy>=1.14.6 in /usr/local/lib/python3.7/dist-packages (from scikit-learn) (1.21.6)\n"
          ]
        }
      ],
      "source": [
        "!pip install GraphRicciCurvature\n",
        "!pip install scikit-learn"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "EA_cRSbcag4i",
        "outputId": "1d442d27-5ea6-4111-e8b6-26f4adfb17b0"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "\t\t\t<script type=\"text/javascript\">\n",
              "\t\t\t<!--\n",
              "\t\t\t\t\n",
              "\t\t\t{\n",
              "\t\t\t\tvar element = document.getElementById('NetworKit_script');\n",
              "\t\t\t\tif (element) {\n",
              "\t\t\t\t\telement.parentNode.removeChild(element);\n",
              "\t\t\t\t}\n",
              "\t\t\t\telement = document.createElement('script');\n",
              "\t\t\t\telement.type = 'text/javascript';\n",
              "\t\t\t\telement.innerHTML = 'function NetworKit_pageEmbed(id) { var i, j; var elements; elements = document.getElementById(id).getElementsByClassName(\"Plot\"); for (i=0; i<elements.length; i++) { elements[i].id = id + \"_Plot_\" + i; var data = elements[i].getAttribute(\"data-image\").split(\"|\"); elements[i].removeAttribute(\"data-image\"); var content = \"<div class=\\\\\"Image\\\\\" id=\\\\\"\" + elements[i].id + \"_Image\\\\\" />\"; elements[i].innerHTML = content; elements[i].setAttribute(\"data-image-index\", 0); elements[i].setAttribute(\"data-image-length\", data.length); for (j=0; j<data.length; j++) { elements[i].setAttribute(\"data-image-\" + j, data[j]); } NetworKit_plotUpdate(elements[i]); elements[i].onclick = function (e) { NetworKit_overlayShow((e.target) ? e.target : e.srcElement); } } elements = document.getElementById(id).getElementsByClassName(\"HeatCell\"); for (i=0; i<elements.length; i++) { var data = parseFloat(elements[i].getAttribute(\"data-heat\")); var color = \"#00FF00\"; if (data <= 1 && data > 0) { color = \"hsla(0, 100%, 75%, \" + (data) + \")\"; } else if (data <= 0 && data >= -1) { color = \"hsla(240, 100%, 75%, \" + (-data) + \")\"; } elements[i].style.backgroundColor = color; } elements = document.getElementById(id).getElementsByClassName(\"Details\"); for (i=0; i<elements.length; i++) { elements[i].setAttribute(\"data-title\", \"-\"); NetworKit_toggleDetails(elements[i]); elements[i].onclick = function (e) { NetworKit_toggleDetails((e.target) ? e.target : e.srcElement); } } elements = document.getElementById(id).getElementsByClassName(\"MathValue\"); for (i=elements.length-1; i>=0; i--) { value = elements[i].innerHTML.trim(); if (value === \"nan\") { elements[i].parentNode.innerHTML = \"\" } } elements = document.getElementById(id).getElementsByClassName(\"SubCategory\"); for (i=elements.length-1; i>=0; i--) { value = elements[i].innerHTML.trim(); if (value === \"\") { elements[i].parentNode.removeChild(elements[i]) } } elements = document.getElementById(id).getElementsByClassName(\"Category\"); for (i=elements.length-1; i>=0; i--) { value = elements[i].innerHTML.trim(); if (value === \"\") { elements[i].parentNode.removeChild(elements[i]) } } var isFirefox = false; try { isFirefox = typeof InstallTrigger !== \"undefined\"; } catch (e) {} if (!isFirefox) { alert(\"Currently the function\\'s output is only fully supported by Firefox.\"); } } function NetworKit_plotUpdate(source) { var index = source.getAttribute(\"data-image-index\"); var data = source.getAttribute(\"data-image-\" + index); var image = document.getElementById(source.id + \"_Image\"); image.style.backgroundImage = \"url(\" + data + \")\"; } function NetworKit_showElement(id, show) { var element = document.getElementById(id); element.style.display = (show) ? \"block\" : \"none\"; } function NetworKit_overlayShow(source) { NetworKit_overlayUpdate(source); NetworKit_showElement(\"NetworKit_Overlay\", true); } function NetworKit_overlayUpdate(source) { document.getElementById(\"NetworKit_Overlay_Title\").innerHTML = source.title; var index = source.getAttribute(\"data-image-index\"); var data = source.getAttribute(\"data-image-\" + index); var image = document.getElementById(\"NetworKit_Overlay_Image\"); image.setAttribute(\"data-id\", source.id); image.style.backgroundImage = \"url(\" + data + \")\"; var link = document.getElementById(\"NetworKit_Overlay_Toolbar_Bottom_Save\"); link.href = data; link.download = source.title + \".svg\"; } function NetworKit_overlayImageShift(delta) { var image = document.getElementById(\"NetworKit_Overlay_Image\"); var source = document.getElementById(image.getAttribute(\"data-id\")); var index = parseInt(source.getAttribute(\"data-image-index\")); var length = parseInt(source.getAttribute(\"data-image-length\")); var index = (index+delta) % length; if (index < 0) { index = length + index; } source.setAttribute(\"data-image-index\", index); NetworKit_overlayUpdate(source); } function NetworKit_toggleDetails(source) { var childs = source.children; var show = false; if (source.getAttribute(\"data-title\") == \"-\") { source.setAttribute(\"data-title\", \"+\"); show = false; } else { source.setAttribute(\"data-title\", \"-\"); show = true; } for (i=0; i<childs.length; i++) { if (show) { childs[i].style.display = \"block\"; } else { childs[i].style.display = \"none\"; } } }';\n",
              "\t\t\t\telement.setAttribute('id', 'NetworKit_script');\n",
              "\t\t\t\tdocument.head.appendChild(element);\n",
              "\t\t\t}\n",
              "\t\t\n",
              "\t\t\t\t\n",
              "\t\t\t{\n",
              "\t\t\t\tvar element = document.getElementById('NetworKit_style');\n",
              "\t\t\t\tif (element) {\n",
              "\t\t\t\t\telement.parentNode.removeChild(element);\n",
              "\t\t\t\t}\n",
              "\t\t\t\telement = document.createElement('style');\n",
              "\t\t\t\telement.type = 'text/css';\n",
              "\t\t\t\telement.innerHTML = '.NetworKit_Page { font-family: Arial, Helvetica, sans-serif; font-size: 14px; } .NetworKit_Page .Value:before { font-family: Arial, Helvetica, sans-serif; font-size: 1.05em; content: attr(data-title) \":\"; margin-left: -2.5em; padding-right: 0.5em; } .NetworKit_Page .Details .Value:before { display: block; } .NetworKit_Page .Value { font-family: monospace; white-space: pre; padding-left: 2.5em; white-space: -moz-pre-wrap !important; white-space: -pre-wrap; white-space: -o-pre-wrap; white-space: pre-wrap; word-wrap: break-word; tab-size: 4; -moz-tab-size: 4; } .NetworKit_Page .Category { clear: both; padding-left: 1em; margin-bottom: 1.5em; } .NetworKit_Page .Category:before { content: attr(data-title); font-size: 1.75em; display: block; margin-left: -0.8em; margin-bottom: 0.5em; } .NetworKit_Page .SubCategory { margin-bottom: 1.5em; padding-left: 1em; } .NetworKit_Page .SubCategory:before { font-size: 1.6em; display: block; margin-left: -0.8em; margin-bottom: 0.5em; } .NetworKit_Page .SubCategory[data-title]:before { content: attr(data-title); } .NetworKit_Page .Block { display: block; } .NetworKit_Page .Block:after { content: \".\"; visibility: hidden; display: block; height: 0; clear: both; } .NetworKit_Page .Block .Thumbnail_Overview, .NetworKit_Page .Block .Thumbnail_ScatterPlot { width: 260px; float: left; } .NetworKit_Page .Block .Thumbnail_Overview img, .NetworKit_Page .Block .Thumbnail_ScatterPlot img { width: 260px; } .NetworKit_Page .Block .Thumbnail_Overview:before, .NetworKit_Page .Block .Thumbnail_ScatterPlot:before { display: block; text-align: center; font-weight: bold; } .NetworKit_Page .Block .Thumbnail_Overview:before { content: attr(data-title); } .NetworKit_Page .HeatCell { font-family: \"Courier New\", Courier, monospace; cursor: pointer; } .NetworKit_Page .HeatCell, .NetworKit_Page .HeatCellName { display: inline; padding: 0.1em; margin-right: 2px; background-color: #FFFFFF } .NetworKit_Page .HeatCellName { margin-left: 0.25em; } .NetworKit_Page .HeatCell:before { content: attr(data-heat); display: inline-block; color: #000000; width: 4em; text-align: center; } .NetworKit_Page .Measure { clear: both; } .NetworKit_Page .Measure .Details { cursor: pointer; } .NetworKit_Page .Measure .Details:before { content: \"[\" attr(data-title) \"]\"; display: block; } .NetworKit_Page .Measure .Details .Value { border-left: 1px dotted black; margin-left: 0.4em; padding-left: 3.5em; pointer-events: none; } .NetworKit_Page .Measure .Details .Spacer:before { content: \".\"; opacity: 0.0; pointer-events: none; } .NetworKit_Page .Measure .Plot { width: 440px; height: 440px; cursor: pointer; float: left; margin-left: -0.9em; margin-right: 20px; } .NetworKit_Page .Measure .Plot .Image { background-repeat: no-repeat; background-position: center center; background-size: contain; height: 100%; pointer-events: none; } .NetworKit_Page .Measure .Stat { width: 500px; float: left; } .NetworKit_Page .Measure .Stat .Group { padding-left: 1.25em; margin-bottom: 0.75em; } .NetworKit_Page .Measure .Stat .Group .Title { font-size: 1.1em; display: block; margin-bottom: 0.3em; margin-left: -0.75em; border-right-style: dotted; border-right-width: 1px; border-bottom-style: dotted; border-bottom-width: 1px; background-color: #D0D0D0; padding-left: 0.2em; } .NetworKit_Page .Measure .Stat .Group .List { -webkit-column-count: 3; -moz-column-count: 3; column-count: 3; } .NetworKit_Page .Measure .Stat .Group .List .Entry { position: relative; line-height: 1.75em; } .NetworKit_Page .Measure .Stat .Group .List .Entry[data-tooltip]:before { position: absolute; left: 0; top: -40px; background-color: #808080; color: #ffffff; height: 30px; line-height: 30px; border-radius: 5px; padding: 0 15px; content: attr(data-tooltip); white-space: nowrap; display: none; } .NetworKit_Page .Measure .Stat .Group .List .Entry[data-tooltip]:after { position: absolute; left: 15px; top: -10px; border-top: 7px solid #808080; border-left: 7px solid transparent; border-right: 7px solid transparent; content: \"\"; display: none; } .NetworKit_Page .Measure .Stat .Group .List .Entry[data-tooltip]:hover:after, .NetworKit_Page .Measure .Stat .Group .List .Entry[data-tooltip]:hover:before { display: block; } .NetworKit_Page .Measure .Stat .Group .List .Entry .MathValue { font-family: \"Courier New\", Courier, monospace; } .NetworKit_Page .Measure:after { content: \".\"; visibility: hidden; display: block; height: 0; clear: both; } .NetworKit_Page .PartitionPie { clear: both; } .NetworKit_Page .PartitionPie img { width: 600px; } #NetworKit_Overlay { left: 0px; top: 0px; display: none; position: absolute; width: 100%; height: 100%; background-color: rgba(0,0,0,0.6); z-index: 1000; } #NetworKit_Overlay_Title { position: absolute; color: white; transform: rotate(-90deg); width: 32em; height: 32em; padding-right: 0.5em; padding-top: 0.5em; text-align: right; font-size: 40px; } #NetworKit_Overlay .button { background: white; cursor: pointer; } #NetworKit_Overlay .button:before { size: 13px; display: inline-block; text-align: center; margin-top: 0.5em; margin-bottom: 0.5em; width: 1.5em; height: 1.5em; } #NetworKit_Overlay .icon-close:before { content: \"X\"; } #NetworKit_Overlay .icon-previous:before { content: \"P\"; } #NetworKit_Overlay .icon-next:before { content: \"N\"; } #NetworKit_Overlay .icon-save:before { content: \"S\"; } #NetworKit_Overlay_Toolbar_Top, #NetworKit_Overlay_Toolbar_Bottom { position: absolute; width: 40px; right: 13px; text-align: right; z-index: 1100; } #NetworKit_Overlay_Toolbar_Top { top: 0.5em; } #NetworKit_Overlay_Toolbar_Bottom { Bottom: 0.5em; } #NetworKit_Overlay_ImageContainer { position: absolute; top: 5%; left: 5%; height: 90%; width: 90%; background-repeat: no-repeat; background-position: center center; background-size: contain; } #NetworKit_Overlay_Image { height: 100%; width: 100%; background-repeat: no-repeat; background-position: center center; background-size: contain; }';\n",
              "\t\t\t\telement.setAttribute('id', 'NetworKit_style');\n",
              "\t\t\t\tdocument.head.appendChild(element);\n",
              "\t\t\t}\n",
              "\t\t\n",
              "\t\t\t\t\n",
              "\t\t\t{\n",
              "\t\t\t\tvar element = document.getElementById('NetworKit_Overlay');\n",
              "\t\t\t\tif (element) {\n",
              "\t\t\t\t\telement.parentNode.removeChild(element);\n",
              "\t\t\t\t}\n",
              "\t\t\t\telement = document.createElement('div');\n",
              "\t\t\t\telement.innerHTML = '<div id=\"NetworKit_Overlay_Toolbar_Top\"><div class=\"button icon-close\" id=\"NetworKit_Overlay_Close\" /></div><div id=\"NetworKit_Overlay_Title\" /> <div id=\"NetworKit_Overlay_ImageContainer\"> <div id=\"NetworKit_Overlay_Image\" /> </div> <div id=\"NetworKit_Overlay_Toolbar_Bottom\"> <div class=\"button icon-previous\" onclick=\"NetworKit_overlayImageShift(-1)\" /> <div class=\"button icon-next\" onclick=\"NetworKit_overlayImageShift(1)\" /> <a id=\"NetworKit_Overlay_Toolbar_Bottom_Save\"><div class=\"button icon-save\" /></a> </div>';\n",
              "\t\t\t\telement.setAttribute('id', 'NetworKit_Overlay');\n",
              "\t\t\t\tdocument.body.appendChild(element);\n",
              "\t\t\t\tdocument.getElementById('NetworKit_Overlay_Close').onclick = function (e) {\n",
              "\t\t\t\t\tdocument.getElementById('NetworKit_Overlay').style.display = 'none';\n",
              "\t\t\t\t}\n",
              "\t\t\t}\n",
              "\t\t\n",
              "\t\t\t-->\n",
              "\t\t\t</script>\n",
              "\t\t"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.colors as colors\n",
        "import numpy as np\n",
        "from datetime import datetime,timedelta\n",
        "import networkx as nx\n",
        "import math\n",
        "# to print logs in jupyter notebook\n",
        "import logging\n",
        "logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.ERROR)\n",
        "\n",
        "# load GraphRicciCuravture package\n",
        "from GraphRicciCurvature.OllivierRicci import OllivierRicci\n",
        "\n",
        "# load python-louvain for modularity computation\n",
        "# import community as community_louvain\n",
        "from community import community_louvain\n",
        "# for ARI computation\n",
        "from sklearn import preprocessing, metrics\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from networkx.utils.misc import edges_equal\n",
        "from networkx.readwrite import edgelist\n",
        "def howmany_cluster(clustering,good_cut):\n",
        "    good_idx = np.where(clustering == good_cut)[0][0]\n",
        "    good_cluster = clustering[good_idx][1]\n",
        "    howmany = len(set(clustering[good_idx][1].values()))\n",
        "    for i in range(howmany-1):\n",
        "        globals()[f'clu_{i}'] = [] \n",
        "        for node,qqq in good_cluster.items():\n",
        "            if qqq == i: \n",
        "                globals()[f'clu_{i}'].append(node)\n",
        "\n",
        "def draw_graph(G):\n",
        "    pos = nx.spring_layout(G)\n",
        "    # colors = nx.get_node_attributes(G,'color').values()\n",
        "    colors = [node[1]['color'] for node in G.nodes(data=True)]\n",
        "    sizes  = [node[1]['size'] for node in G.nodes(data=True)]\n",
        "\n",
        "    # nx.draw_networkx_nodes(G, pos,colors=colors)\n",
        "    # nx.draw_networkx_labels(G, pos)\n",
        "    # nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)\n",
        "    nx.draw(G, node_color=colors, node_size=sizes, with_labels=True)\n",
        "def draw_ricci_graph(G):\n",
        "    \"\"\"\n",
        "    A helper function to draw a nx graph with community.\n",
        "    \"\"\"\n",
        "    edgevmin = -0.2; edgevmax = 0.5\n",
        "    edge_cmap = plt.cm.seismic\n",
        "    labels = [node[1]['month'] for node in G.nodes(data=True)]\n",
        "    colors = [node[1]['color'] for node in G.nodes(data=True)]\n",
        "    sizes  = [node[1]['size'] for node in G.nodes(data=True)]\n",
        "    curavature = [edge[2]['ricciCurvature'] for edge in G.edges(data=True)]\n",
        "    # weight = [edge[2]['weight'] for edge in G.edges(data=True)]\n",
        "    le = preprocessing.LabelEncoder()\n",
        "    \n",
        "    nx.draw_spring(G, nodelist=G.nodes(),\n",
        "                   node_color=colors, node_size=sizes, edgelist=G.edges(),\n",
        "                   edge_color=curavature, width=2, edge_cmap=edge_cmap,\n",
        "                   edge_vmin=edgevmin, edge_vmax=edgevmax,style='solid',\n",
        "                   connectionstyle='arc3,rad=0.05',\n",
        "                   cmap=plt.cm.rainbow,\n",
        "                   alpha=0.5 )\n",
        "    sm = plt.cm.ScalarMappable(cmap=edge_cmap, norm=plt.Normalize(vmin = edgevmin, vmax=edgevmax))\n",
        "    plt.colorbar(sm)\n",
        "    plt.show()\n",
        "\n",
        "def check_accuracy(G_origin, weight=\"weight\", clustering_label=\"value\", plot_cut=True):\n",
        "    \"\"\"To check the clustering quality while cut the edges with weight using different threshold\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G_origin : NetworkX graph\n",
        "        A graph with ``weight`` as Ricci flow metric to cut.\n",
        "    weight: float\n",
        "        The edge weight used as Ricci flow metric. (Default value = \"weight\")\n",
        "    clustering_label : str\n",
        "        Node attribute name for ground truth.\n",
        "    plot_cut: bool\n",
        "        To plot the good guessed cut or not.\n",
        "\n",
        "    \"\"\"\n",
        "    G = G_origin.copy()\n",
        "    modularity, ari = [], []\n",
        "    maxw = max(nx.get_edge_attributes(G, weight).values())\n",
        "    cutoff_range = np.arange(maxw, 1, -0.025)\n",
        "    allcluster=[]\n",
        "    for cutoff in cutoff_range:\n",
        "        edge_trim_list = []\n",
        "        for n1, n2 in G.edges():\n",
        "            if G[n1][n2][weight] > cutoff:\n",
        "                edge_trim_list.append((n1, n2))\n",
        "        G.remove_edges_from(edge_trim_list)\n",
        "\n",
        "        # Get connected component after cut as clustering\n",
        "        clustering = {c: idx for idx, comp in enumerate(nx.connected_components(G)) for c in comp}\n",
        "        allcluster.append([cutoff,clustering])\n",
        "        # Compute modularity and ari\n",
        "        modularity.append(community_louvain.modularity(clustering, G, weight))\n",
        "        ari.append(ARI(G, clustering, clustering_label=clustering_label))\n",
        "\n",
        "    plt.xlim(maxw, 0)\n",
        "    plt.xlabel(\"Edge weight cutoff\")\n",
        "    plt.plot(cutoff_range, modularity, alpha=0.8)\n",
        "    plt.plot(cutoff_range, ari, alpha=0.8)\n",
        "    \n",
        "\n",
        "    if plot_cut:\n",
        "        good_cut = -1\n",
        "        mod_last = modularity[-1]\n",
        "        drop_threshold = 0.01  # at least drop this much to considered as a drop for good_cut\n",
        "\n",
        "        # check drop from 1 -> maxw\n",
        "        for i in range(len(modularity) - 1, 0, -1):\n",
        "            mod_now = modularity[i]\n",
        "            if mod_last > mod_now > 1e-4 and abs(mod_last - mod_now) / mod_last > drop_threshold:\n",
        "                if good_cut != -1:\n",
        "                    print(\"Other cut:%f, diff:%f, mod_now:%f, mod_last:%f, ari:%f\" % (\n",
        "                        cutoff_range[i + 1], mod_last - mod_now, mod_now, mod_last, ari[i + 1]))\n",
        "                else:\n",
        "                    good_cut = cutoff_range[i + 1]\n",
        "                    print(\"*Good Cut:%f, diff:%f, mod_now:%f, mod_last:%f, ari:%f\" % (\n",
        "                        good_cut, mod_last - mod_now, mod_now, mod_last, ari[i + 1]))\n",
        "            mod_last = mod_now\n",
        "\n",
        "        plt.axvline(x=good_cut, color=\"red\")\n",
        "        print('='*60)\n",
        "        print( f'Good cut at {good_cut}')\n",
        "        plt.legend(['Modularity', 'Adjust Rand Index', 'Good cut'])\n",
        "    else:\n",
        "        plt.legend(['Modularity', 'Adjust Rand Index'])\n",
        "    return allcluster, good_cut"
      ],
      "metadata": {
        "id": "JWim0c52EoNZ"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "VrkYNZ0talq7"
      },
      "outputs": [],
      "source": [
        "\n",
        "def show_results(G):\n",
        "    # Print the first five results\n",
        "    print(\"Karate Club Graph, first 5 edges: \")\n",
        "    for n1,n2 in list(G.edges())[:5]:\n",
        "        print(\"Ollivier-Ricci curvature of edge (%s,%s) is %f\" % (n1 ,n2, G[n1][n2][\"ricciCurvature\"]))\n",
        "\n",
        "    # Plot the histogram of Ricci curvatures\n",
        "    plt.subplot(2, 1, 1)\n",
        "    ricci_curvtures = nx.get_edge_attributes(G, \"ricciCurvature\").values()\n",
        "    plt.hist(ricci_curvtures,bins=20)\n",
        "    plt.xlabel('Ricci curvature')\n",
        "    plt.title(\"Histogram of Ricci Curvatures\")\n",
        "\n",
        "    # Plot the histogram of edge weights\n",
        "    plt.subplot(2, 1, 2)\n",
        "    weights = nx.get_edge_attributes(G, \"weight\").values()\n",
        "    plt.hist(weights,bins=20)\n",
        "    plt.xlabel('Edge weight')\n",
        "    plt.title(\"Histogram of Edge weights\")\n",
        "\n",
        "    plt.tight_layout()\n",
        "def ARI(G, clustering, clustering_label=\"club\"):\n",
        "    \"\"\"\n",
        "    Computer the Adjust Rand Index (clustering accuracy) of \"clustering\" with \"clustering_label\" as ground truth.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G : NetworkX graph\n",
        "        A given NetworkX graph with node attribute \"clustering_label\" as ground truth.\n",
        "    clustering : dict or list or list of set\n",
        "        Predicted community clustering.\n",
        "    clustering_label : str\n",
        "        Node attribute name for ground truth.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    ari : float\n",
        "        Adjust Rand Index for predicted community.        ##這個值的高低代表什麼意思？\n",
        "    \"\"\"\n",
        "\n",
        "    complex_list = nx.get_node_attributes(G, clustering_label)\n",
        "\n",
        "    le = preprocessing.LabelEncoder()\n",
        "    y_true = le.fit_transform(list(complex_list.values()))\n",
        "\n",
        "    if isinstance(clustering, dict):\n",
        "        # python-louvain partition format\n",
        "        y_pred = np.array([clustering[v] for v in complex_list.keys()])\n",
        "    elif isinstance(clustering[0], set):\n",
        "        # networkx partition format\n",
        "        predict_dict = {c: idx for idx, comp in enumerate(clustering) for c in comp}\n",
        "        y_pred = np.array([predict_dict[v] for v in complex_list.keys()])\n",
        "    elif isinstance(clustering, list):\n",
        "        # sklearn partition format\n",
        "        y_pred = clustering\n",
        "    else:\n",
        "        return -1\n",
        "\n",
        "    return metrics.adjusted_rand_score(y_true, y_pred)\n",
        "\n",
        "\n",
        "\n",
        "def my_surgery(G_origin, weight=\"weight\", cut=0):\n",
        "    \"\"\"A simple surgery function that remove the edges with weight above a threshold\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    G_origin : NetworkX graph\n",
        "        A graph with ``weight`` as Ricci flow metric to cut.\n",
        "    weight: str\n",
        "        The edge weight used as Ricci flow metric. (Default value = \"weight\")\n",
        "    cut: float\n",
        "        Manually assigned cutoff point.\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    G : NetworkX graph\n",
        "        A graph after surgery.\n",
        "    \"\"\"\n",
        "    G = G_origin.copy()\n",
        "    w = nx.get_edge_attributes(G, weight)\n",
        "\n",
        "    assert cut >= 0, \"Cut value should be greater than 0.\"\n",
        "    if not cut:\n",
        "        cut = (max(w.values()) - 1.0) * 0.6 + 1.0  # Guess a cut point as default\n",
        "\n",
        "    to_cut = []\n",
        "    for n1, n2 in G.edges():\n",
        "        if G[n1][n2][weight] > cut:\n",
        "            to_cut.append((n1, n2))\n",
        "    print(\"*************** Surgery time ****************\")\n",
        "    print(\"* Cut %d edges.\" % len(to_cut))\n",
        "    G.remove_edges_from(to_cut)\n",
        "    print(\"* Number of nodes now: %d\" % G.number_of_nodes())\n",
        "    print(\"* Number of edges now: %d\" % G.number_of_edges())\n",
        "    cc = list(nx.connected_components(G))\n",
        "    print(\"* Modularity now: %f \" % nx.algorithms.community.quality.modularity(G, cc))    ##這個值的高低代表什麼意思？\n",
        "    print(\"* ARI now: %f \" % ARI(G, cc))\n",
        "    print(\"*********************************************\")\n",
        "\n",
        "    return G\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G = nx.read_gpickle(\"/content/drive/MyDrive/Final_project/Gtest7.gpickle\")"
      ],
      "metadata": {
        "id": "SBo8EfvnBQYU"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 607
        },
        "id": "6mSjWRQHbBEP",
        "outputId": "3b44a2fe-3a73-4d53-b98e-26e2303d193d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure(figsize=(8,8))\n",
        "draw_graph(G)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "YlkHVZWqbHdk"
      },
      "outputs": [],
      "source": [
        "# Start a Ricci flow with Lin-Yau's probability distribution setting with 4 process.\n",
        "G_copy = G.copy()\n",
        "orf = OllivierRicci(G_copy,alpha=0.5, base=math.e , exp_power=2, verbose=\"INFO\") #,shortest_path='pairwise'\n",
        "\n",
        "orf.set_verbose(\"ERROR\") # mute logs\n",
        "orf.compute_ricci_flow(iterations=10) \n",
        "G_rf = orf.G.copy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 401
        },
        "id": "5FFCbl32bJFk",
        "outputId": "63fc44af-d95c-4289-e489-c14416f72bd4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Karate Club Graph, first 5 edges: \n",
            "Ollivier-Ricci curvature of edge (0,4) is 0.000000\n",
            "Ollivier-Ricci curvature of edge (0,10) is 0.571376\n",
            "Ollivier-Ricci curvature of edge (0,17) is 0.571366\n",
            "Ollivier-Ricci curvature of edge (0,23) is 0.003904\n",
            "Ollivier-Ricci curvature of edge (0,37) is 0.000571\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "show_results(G_rf)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 782
        },
        "id": "LVzcsXr5bQoF",
        "outputId": "f684ef4e-d329-4662-b2c3-6c571d29fe2a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*Good Cut:4.328649, diff:0.054748, mod_now:0.688144, mod_last:0.742892, ari:0.314077\n",
            "Other cut:4.353649, diff:0.214046, mod_now:0.474098, mod_last:0.688144, ari:0.314077\n",
            "Other cut:4.378649, diff:0.025083, mod_now:0.449015, mod_last:0.474098, ari:0.314077\n",
            "Other cut:4.403649, diff:0.071274, mod_now:0.377741, mod_last:0.449015, ari:0.314077\n",
            "Other cut:7.953649, diff:0.016859, mod_now:0.695862, mod_last:0.712721, ari:0.284172\n",
            "Other cut:7.978649, diff:0.011990, mod_now:0.683872, mod_last:0.695862, ari:0.284172\n",
            "Other cut:8.003649, diff:0.010745, mod_now:0.673127, mod_last:0.683872, ari:0.284172\n",
            "Other cut:8.028649, diff:0.008077, mod_now:0.665050, mod_last:0.673127, ari:0.284172\n",
            "Other cut:8.678649, diff:0.009822, mod_now:0.655228, mod_last:0.665050, ari:0.284172\n",
            "Other cut:9.178649, diff:0.204986, mod_now:0.463778, mod_last:0.668764, ari:0.273869\n",
            "Other cut:9.203649, diff:0.005050, mod_now:0.458728, mod_last:0.463778, ari:0.230747\n",
            "Other cut:9.403649, diff:0.006021, mod_now:0.456485, mod_last:0.462506, ari:0.228313\n",
            "Other cut:9.478649, diff:0.054287, mod_now:0.399213, mod_last:0.453499, ari:0.228313\n",
            "Other cut:9.528649, diff:0.019869, mod_now:0.379344, mod_last:0.399213, ari:0.084132\n",
            "Other cut:9.553649, diff:0.016491, mod_now:0.362853, mod_last:0.379344, ari:0.084132\n",
            "Other cut:10.328649, diff:0.010287, mod_now:0.372795, mod_last:0.383081, ari:0.084178\n",
            "Other cut:10.353649, diff:0.012089, mod_now:0.360706, mod_last:0.372795, ari:0.084178\n",
            "Other cut:10.378649, diff:0.021046, mod_now:0.339660, mod_last:0.360706, ari:0.084178\n",
            "Other cut:10.928649, diff:0.004275, mod_now:0.335385, mod_last:0.339660, ari:0.084178\n",
            "Other cut:11.278649, diff:0.005507, mod_now:0.332197, mod_last:0.337703, ari:0.073589\n",
            "Other cut:11.878649, diff:0.017440, mod_now:0.311925, mod_last:0.329365, ari:0.073589\n",
            "Other cut:11.953649, diff:0.303117, mod_now:0.008170, mod_last:0.311287, ari:0.073589\n",
            "Other cut:12.278649, diff:0.000245, mod_now:0.007882, mod_last:0.008128, ari:0.008732\n",
            "Other cut:12.403649, diff:0.000377, mod_now:0.007465, mod_last:0.007843, ari:0.008732\n",
            "Other cut:13.003649, diff:0.000092, mod_now:0.007337, mod_last:0.007429, ari:0.008732\n",
            "Other cut:13.728649, diff:0.000092, mod_now:0.007136, mod_last:0.007228, ari:0.003376\n",
            "Other cut:16.178649, diff:0.000143, mod_now:0.012189, mod_last:0.012331, ari:0.003406\n",
            "============================================================\n",
            "Good cut at 4.32864883034102\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "clustering,good_cut = check_accuracy(G_rf, clustering_label=\"month\",plot_cut=True)\n",
        "howmany_cluster(clustering,good_cut)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 598
        },
        "id": "p0lb2ORtytnL",
        "outputId": "5676ec64-4225-4e65-93d8-b94ab1c51d21"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*************** Surgery time ****************\n",
            "* Cut 672 edges.\n",
            "* Number of nodes now: 221\n",
            "* Number of edges now: 5347\n",
            "* Modularity now: 0.742892 \n",
            "* ARI now: 1.000000 \n",
            "*********************************************\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x576 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure(figsize=(10,8))\n",
        "plt.subplot(111)\n",
        "draw_ricci_graph(my_surgery(G_rf, cut=good_cut))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### another way to find cluster but you need to cut! "
      ],
      "metadata": {
        "id": "b_0d__4iF7eU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KNLvMC9uNq7g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d0d088a1-d647-472c-91a0-ed3cce2897ab"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*************** Surgery time ****************\n",
            "* Cut 2370 edges.\n",
            "* Number of nodes now: 229\n",
            "* Number of edges now: 3651\n",
            "* Modularity now: 0.307337 \n",
            "* ARI now: 1.000000 \n",
            "*********************************************\n",
            "0 {0, 193, 227, 4, 228, 37, 38, 10, 174, 17, 23, 184}\n",
            "1 {1}\n",
            "2 {2, 35, 49, 50, 186}\n",
            "3 {34, 3, 83, 57, 219}\n",
            "4 {5}\n",
            "5 {6, 7}\n",
            "6 {8, 22, 24, 26, 159, 32, 170, 44, 45, 182, 183, 59, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 78, 80, 194, 81, 87, 88, 89, 90, 91, 92, 225}\n",
            "7 {9, 202}\n",
            "8 {11, 171, 109, 82, 223}\n",
            "9 {198, 199, 12, 205, 176, 177, 213, 214, 188, 189}\n",
            "10 {195, 13, 79, 175, 212}\n",
            "11 {14, 29, 42, 48, 51, 53, 54, 55, 56, 84, 85, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, 129, 130, 132, 133, 134, 135, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 178, 179, 181, 187, 191, 200, 201, 206, 207, 208, 217}\n",
            "12 {226, 21, 15}\n",
            "13 {16, 218}\n",
            "14 {18}\n",
            "15 {19, 196}\n",
            "16 {20}\n",
            "17 {25}\n",
            "18 {27}\n",
            "19 {28}\n",
            "20 {30}\n",
            "21 {203, 31}\n",
            "22 {33}\n",
            "23 {36}\n",
            "24 {40, 43, 39}\n",
            "25 {41}\n",
            "26 {46}\n",
            "27 {52, 47}\n",
            "28 {58}\n",
            "29 {60}\n",
            "30 {210, 77}\n",
            "31 {216, 222, 86}\n",
            "32 {107}\n",
            "33 {131, 127}\n",
            "34 {136}\n",
            "35 {172, 173}\n",
            "36 {180}\n",
            "37 {185}\n",
            "38 {220, 221, 190}\n",
            "39 {192, 224}\n",
            "40 {197}\n",
            "41 {204}\n",
            "42 {209, 211}\n",
            "43 {215}\n"
          ]
        }
      ],
      "source": [
        "\n",
        "G_cut = my_surgery(G_rf, cut=good_cut)\n",
        "for idx, comp in enumerate(nx.connected_components(G_cut)):\n",
        "    print(idx,comp)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nx.write_gpickle(G_cut,'/content/drive/MyDrive/Final_project/Gtest7_goodcut_cut3.gpickle')"
      ],
      "metadata": {
        "id": "2P4Q1EytKeIN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "a5K295UsK1Hg"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "02_RicciCurvature.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}