{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "39f3e87c",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Visualization of clusters\n",
    "\"\"\"\n",
    "import sys\n",
    "\n",
    "try:\n",
    "    import networkx as nx\n",
    "except ImportError:\n",
    "    sys.stderr.write(\"Networkx not present\\n\")\n",
    "    raise\n",
    "    \n",
    "try:\n",
    "    from matplotlib.pylab import show, cm, axis\n",
    "except ImportError:\n",
    "    sys.stderr.write(\"Matplotlib not present\\n\")\n",
    "    raise\n",
    "\n",
    "\n",
    "def draw_graph(matrix, clusters, **kwargs):\n",
    "    \"\"\"\n",
    "    Visualize the clustering\n",
    "    \n",
    "    :param matrix: The unprocessed adjacency matrix\n",
    "    :param clusters: list of tuples containing clusters as returned\n",
    "                     by 'get_clusters'\n",
    "    :param kwargs: Additional keyword arguments to be passed to\n",
    "                   networkx.draw_networkx\n",
    "    \"\"\"\n",
    "    # make a networkx graph from the adjacency matrix\n",
    "    graph = nx.Graph(matrix)\n",
    "    \n",
    "    # map node to cluster id for colors\n",
    "    cluster_map = {node: i for i, cluster in enumerate(clusters) for node in cluster}\n",
    "    colors = [cluster_map[i] for i in range(len(graph.nodes()))]\n",
    "    \n",
    "    # if colormap not specified in kwargs, use a default\n",
    "    if not kwargs.get(\"cmap\", False):\n",
    "        kwargs[\"cmap\"] = cm.tab20\n",
    "    \n",
    "    # draw\n",
    "    nx.draw_networkx(graph, node_color=colors, **kwargs)\n",
    "    axis(\"off\")\n",
    "    show(block=False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "21b5c3db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# from scipy.sparse import isspmatrix, dok_matrix, csc_matrix\n",
    "# import sklearn.preprocessing\n",
    "\n",
    "\n",
    "# def sparse_allclose(a, b, rtol=1e-5, atol=1e-8):\n",
    "#     \"\"\"\n",
    "#     Version of np.allclose for use with sparse matrices\n",
    "#     \"\"\"\n",
    "#     c = np.abs(a - b) - rtol * np.abs(b)\n",
    "#     # noinspection PyUnresolvedReferences\n",
    "#     return c.max() <= atol\n",
    "\n",
    "\n",
    "# def normalize(matrix):\n",
    "#     \"\"\"\n",
    "#     Normalize the columns of the given matrix\n",
    "    \n",
    "#     :param matrix: The matrix to be normalized\n",
    "#     :returns: The normalized matrix\n",
    "#     \"\"\"\n",
    "#     return sklearn.preprocessing.normalize(matrix, norm=\"l1\", axis=0)\n",
    "\n",
    "\n",
    "# def inflate(matrix, power):\n",
    "#     \"\"\"\n",
    "#     Apply cluster inflation to the given matrix by raising\n",
    "#     each element to the given power.\n",
    "    \n",
    "#     :param matrix: The matrix to be inflated\n",
    "#     :param power: Cluster inflation parameter\n",
    "#     :returns: The inflated matrix\n",
    "#     \"\"\"\n",
    "#     if isspmatrix(matrix):\n",
    "#         return normalize(matrix.power(power))\n",
    "\n",
    "#     return normalize(np.power(matrix, power))\n",
    "\n",
    "\n",
    "# def expand(matrix, power):\n",
    "#     \"\"\"\n",
    "#     Apply cluster expansion to the given matrix by raising\n",
    "#     the matrix to the given power.\n",
    "    \n",
    "#     :param matrix: The matrix to be expanded\n",
    "#     :param power: Cluster expansion parameter\n",
    "#     :returns: The expanded matrix\n",
    "#     \"\"\"\n",
    "#     if isspmatrix(matrix):\n",
    "#         return matrix ** power\n",
    "\n",
    "#     return np.linalg.matrix_power(matrix, power)\n",
    "\n",
    "\n",
    "# def add_self_loops(matrix, loop_value):\n",
    "#     \"\"\"\n",
    "#     Add self-loops to the matrix by setting the diagonal\n",
    "#     to loop_value\n",
    "    \n",
    "#     :param matrix: The matrix to add loops to\n",
    "#     :param loop_value: Value to use for self-loops\n",
    "#     :returns: The matrix with self-loops\n",
    "#     \"\"\"\n",
    "#     shape = matrix.shape\n",
    "#     assert shape[0] == shape[1], \"Error, matrix is not square\"\n",
    "\n",
    "#     if isspmatrix(matrix):\n",
    "#         new_matrix = matrix.todok()\n",
    "#     else:\n",
    "#         new_matrix = matrix.copy()\n",
    "\n",
    "#     for i in range(shape[0]):\n",
    "#         new_matrix[i, i] = loop_value\n",
    "\n",
    "#     if isspmatrix(matrix):\n",
    "#         return new_matrix.tocsc()\n",
    "\n",
    "#     return new_matrix\n",
    "\n",
    "\n",
    "# def prune(matrix, threshold):\n",
    "#     \"\"\"\n",
    "#     Prune the matrix so that very small edges are removed.\n",
    "#     The maximum value in each column is never pruned.\n",
    "    \n",
    "#     :param matrix: The matrix to be pruned\n",
    "#     :param threshold: The value below which edges will be removed\n",
    "#     :returns: The pruned matrix\n",
    "#     \"\"\"\n",
    "#     if isspmatrix(matrix):\n",
    "#         pruned = dok_matrix(matrix.shape)\n",
    "#         pruned[matrix >= threshold] = matrix[matrix >= threshold]\n",
    "#         pruned = pruned.tocsc()\n",
    "#     else:\n",
    "#         pruned = matrix.copy()\n",
    "#         pruned[pruned < threshold] = 0\n",
    "\n",
    "#     # keep max value in each column. same behaviour for dense/sparse\n",
    "#     num_cols = matrix.shape[1]\n",
    "#     row_indices = matrix.argmax(axis=0).reshape((num_cols,))\n",
    "#     col_indices = np.arange(num_cols)\n",
    "#     pruned[row_indices, col_indices] = matrix[row_indices, col_indices]\n",
    "\n",
    "#     return pruned\n",
    "\n",
    "\n",
    "# def converged(matrix1, matrix2):\n",
    "#     \"\"\"\n",
    "#     Check for convergence by determining if \n",
    "#     matrix1 and matrix2 are approximately equal.\n",
    "    \n",
    "#     :param matrix1: The matrix to compare with matrix2\n",
    "#     :param matrix2: The matrix to compare with matrix1\n",
    "#     :returns: True if matrix1 and matrix2 approximately equal\n",
    "#     \"\"\"\n",
    "#     if isspmatrix(matrix1) or isspmatrix(matrix2):\n",
    "#         return sparse_allclose(matrix1, matrix2)\n",
    "\n",
    "#     return np.allclose(matrix1, matrix2)\n",
    "\n",
    "\n",
    "# def iterate(matrix, expansion, inflation):\n",
    "#     \"\"\"\n",
    "#     Run a single iteration (expansion + inflation) of the mcl algorithm\n",
    "    \n",
    "#     :param matrix: The matrix to perform the iteration on\n",
    "#     :param expansion: Cluster expansion factor\n",
    "#     :param inflation: Cluster inflation factor\n",
    "#     \"\"\"\n",
    "#     # Expansion\n",
    "#     matrix = expand(matrix, expansion)\n",
    "\n",
    "#     # Inflation\n",
    "#     matrix = inflate(matrix, inflation)\n",
    "\n",
    "#     return matrix\n",
    "\n",
    "\n",
    "# def get_clusters(matrix):\n",
    "#     \"\"\"\n",
    "#     Retrieve the clusters from the matrix\n",
    "    \n",
    "#     :param matrix: The matrix produced by the MCL algorithm\n",
    "#     :returns: A list of tuples where each tuple represents a cluster and\n",
    "#               contains the indices of the nodes belonging to the cluster\n",
    "#     \"\"\"\n",
    "#     if not isspmatrix(matrix):\n",
    "#         # cast to sparse so that we don't need to handle different \n",
    "#         # matrix types\n",
    "#         matrix = csc_matrix(matrix)\n",
    "\n",
    "#     # get the attractors - non-zero elements of the matrix diagonal\n",
    "#     attractors = matrix.diagonal().nonzero()[0]\n",
    "\n",
    "#     # somewhere to put the clusters\n",
    "#     clusters = set()\n",
    "\n",
    "#     # the nodes in the same row as each attractor form a cluster\n",
    "#     for attractor in attractors:\n",
    "#         cluster = tuple(matrix.getrow(attractor).nonzero()[1].tolist())\n",
    "#         clusters.add(cluster)\n",
    "\n",
    "#     return sorted(list(clusters))\n",
    "\n",
    "\n",
    "# def run_mcl(matrix, expansion=2, inflation=2, loop_value=1,\n",
    "#             iterations=100, pruning_threshold=0.001, pruning_frequency=1,\n",
    "#             convergence_check_frequency=1):\n",
    "#     \"\"\"\n",
    "#     Perform MCL on the given similarity matrix\n",
    "    \n",
    "#     :param matrix: The similarity matrix to cluster\n",
    "#     :param expansion: The cluster expansion factor\n",
    "#     :param inflation: The cluster inflation factor\n",
    "#     :param loop_value: Initialization value for self-loops\n",
    "#     :param iterations: Maximum number of iterations\n",
    "#            (actual number of iterations will be less if convergence is reached)\n",
    "#     :param pruning_threshold: Threshold below which matrix elements will be set\n",
    "#            set to 0\n",
    "#     :param pruning_frequency: Perform pruning every 'pruning_frequency'\n",
    "#            iterations. \n",
    "#     :param convergence_check_frequency: Perform the check for convergence\n",
    "#            every convergence_check_frequency iterations\n",
    "#     :param verbose: Print extra information to the console\n",
    "#     :returns: The final matrix\n",
    "#     \"\"\"\n",
    "#     assert expansion > 1, \"Invalid expansion parameter\"\n",
    "#     assert inflation > 1, \"Invalid inflation parameter\"\n",
    "#     assert loop_value >= 0, \"Invalid loop_value\"\n",
    "#     assert iterations > 0, \"Invalid number of iterations\"\n",
    "#     assert pruning_threshold >= 0, \"Invalid pruning_threshold\"\n",
    "#     assert pruning_frequency > 0, \"Invalid pruning_frequency\"\n",
    "#     assert convergence_check_frequency > 0, \"Invalid convergence_check_frequency\"\n",
    "\n",
    "\n",
    "#     print(\"-\" * 50)\n",
    "#     print(\"MCL Parameters\")\n",
    "#     print(\"Expansion: {}\".format(expansion))\n",
    "#     print(\"Inflation: {}\".format(inflation))\n",
    "#     if pruning_threshold > 0:\n",
    "#         print(\"Pruning threshold: {}, frequency: {} iteration{}\".format(\n",
    "#             pruning_threshold, pruning_frequency, \"s\" if pruning_frequency > 1 else \"\"))\n",
    "#     else:\n",
    "#         print(\"No pruning\")\n",
    "#     print(\"Convergence check: {} iteration{}\".format(\n",
    "#         convergence_check_frequency, \"s\" if convergence_check_frequency > 1 else \"\"))\n",
    "#     print(\"Maximum iterations: {}\".format(iterations))\n",
    "#     print(\"{} matrix mode\".format(\"Sparse\" if isspmatrix(matrix) else \"Dense\"))\n",
    "#     print(\"-\" * 50)\n",
    "\n",
    "#     # Initialize self-loops\n",
    "#     if loop_value > 0:\n",
    "#         matrix = add_self_loops(matrix, loop_value)\n",
    "\n",
    "#     # Normalize\n",
    "#     matrix = normalize(matrix)\n",
    "\n",
    "#     # iterations\n",
    "#     for i in range(iterations):\n",
    "#         print(\"Iteration {}\".format(i + 1))\n",
    "\n",
    "#         # store current matrix for convergence checking\n",
    "#         last_mat = matrix.copy()\n",
    "\n",
    "#         # perform MCL expansion and inflation\n",
    "#         matrix = iterate(matrix, expansion, inflation)\n",
    "\n",
    "#         # prune\n",
    "#         if pruning_threshold > 0 and i % pruning_frequency == pruning_frequency - 1:\n",
    "#             print(\"Pruning\")\n",
    "#             matrix = prune(matrix, pruning_threshold)\n",
    "\n",
    "#         # Check for convergence\n",
    "#         if i % convergence_check_frequency == convergence_check_frequency - 1:\n",
    "#             print(\"Checking for convergence\")\n",
    "#             if converged(matrix, last_mat):\n",
    "#                 print(\"Converged after {} iteration{}\".format(i + 1, \"s\" if i > 0 else \"\"))\n",
    "#                 break\n",
    "\n",
    "#     print(\"-\" * 50)\n",
    "\n",
    "#     return matrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d9a19c8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# # # G = nx.karate_club_graph()\n",
    "# # G = nx.balanced_tree(2,3)\n",
    "# G = nx.balanced_tree(2,5)\n",
    "# # Build adjacency matrix\n",
    "# A = nx.to_numpy_matrix(G)\n",
    "# # Run MCL algorithm\n",
    "# result = run_mcl(A)\n",
    "# clusters = get_clusters(result)\n",
    "# print(clusters)\n",
    "# draw_graph(A, clusters, node_size=50, with_labels=True, edge_color=\"silver\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c081c0fd",
   "metadata": {},
   "source": [
    "DRUGI ALGORYTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "3580fb47",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "\n",
    "def draw(G, A, cluster_map):\n",
    "\n",
    "    graph = nx.Graph(G)\n",
    "    clust_map = {}\n",
    "    for k, vals in cluster_map.items():\n",
    "        for v in vals:\n",
    "            clust_map[v] = k\n",
    "\n",
    "    colors = []\n",
    "    for i in range(len(G.nodes())):\n",
    "        colors.append(clust_map.get(i, 100))\n",
    "    \n",
    "    nx.draw_networkx(graph,node_color =colors,linewidths=7)\n",
    "    axis(\"off\")\n",
    "    show(block=False)\n",
    "\n",
    "def normalize(A):\n",
    "#   Normalize the columns of the given matrix\n",
    "    return sklearn.preprocessing.normalize(A, norm=\"l1\", axis=0)\n",
    "\n",
    "def inflate(A, inflate_factor):\n",
    "#   Apply cluster inflation to the given matrix by raising each element to the given power.\n",
    "    return normalize(np.power(A, inflate_factor))\n",
    "\n",
    "def expand(A, expand_factor):\n",
    "#   Apply cluster expansion to the given matrix by raising the matrix to the given power.\n",
    "    return np.linalg.matrix_power(A, expand_factor)\n",
    "\n",
    "def add_diag(A, mult_factor):\n",
    "#    Add self-loops to the matrix by setting the diagonal to 1\n",
    "    return A + mult_factor * np.identity(A.shape[0])\n",
    "\n",
    "def get_clusters(A):\n",
    "    clusters = []\n",
    "    for i, r in enumerate((A>0).tolist()):\n",
    "        if r[i]:\n",
    "            clusters.append(A[i,:]>0)\n",
    "\n",
    "    clust_map  ={}\n",
    "    for cn , c in enumerate(clusters):\n",
    "        for x in  [ i for i, x in enumerate(c) if x ]:\n",
    "            clust_map[cn] = clust_map.get(cn, [])  + [x]\n",
    "    return clust_map\n",
    "\n",
    "def stop(M, i):\n",
    "    if i%5==4:\n",
    "        m = np.max( M**2 - M) - np.min( M**2 - M)\n",
    "        if m==0:\n",
    "            print(\"Stop at iteration %s\" % i)\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "\n",
    "def mcl(M, expand_factor = 2, inflate_factor = 2, max_loop = 10 , mult_factor = 1):\n",
    "    M = add_diag(M, mult_factor)\n",
    "    M = normalize(M)\n",
    "    \n",
    "    for i in range(max_loop):\n",
    "        M = expand(M, expand_factor)\n",
    "        M = inflate(M, inflate_factor)\n",
    "        \n",
    "        if stop(M, i): break\n",
    "\n",
    "    clusters = get_clusters(M)\n",
    "    return M, clusters\n",
    "\n",
    "def networkx_mcl(G, expand_factor = 2, inflate_factor = 2, max_loop = 50 , mult_factor = 1):\n",
    "    A = nx.adjacency_matrix(G)\n",
    "    return mcl(np.array(A.todense()), expand_factor, inflate_factor, max_loop, mult_factor)\n",
    "\n",
    "\n",
    "def calculate_and_draw(Graph): \n",
    "    M = nx.to_numpy_matrix(Graph)\n",
    "    print(\" number of nodes: %s\\n\" % M.shape[0])\n",
    "    \n",
    "    M, clusters = networkx_mcl(Graph)\n",
    "    [print(key, \": \", value) for key, value in clusters.items()]\n",
    "    \n",
    "    draw(Graph, M, clusters)\n",
    "\n",
    "\n",
    "# https://networkx.org/documentation/stable/reference/generators.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "dying-impact",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " number of nodes: 16\n",
      "\n",
      "Stop at iteration 14\n",
      "0 :  [0, 1]\n",
      "1 :  [2, 3]\n",
      "2 :  [4, 5]\n",
      "3 :  [6, 7]\n",
      "4 :  [8, 9]\n",
      "5 :  [10, 12]\n",
      "6 :  [11, 13]\n",
      "7 :  [14, 15]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G_bin = nx.binomial_tree(4)\n",
    "calculate_and_draw(G_bin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "wooden-harbor",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " number of nodes: 15\n",
      "\n",
      "0 :  [0, 1, 3, 7, 8]\n",
      "1 :  [0, 1, 4, 9, 10]\n",
      "2 :  [0, 2, 5, 11, 12]\n",
      "3 :  [0, 2, 6, 13, 14]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G_balanced = nx.balanced_tree(2,3)\n",
    "calculate_and_draw(G_balanced)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "perceived-principal",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " number of nodes: 63\n",
      "\n",
      "0 :  [0, 1, 3, 4]\n",
      "1 :  [0, 2, 5, 6]\n",
      "2 :  [7, 15, 31, 32]\n",
      "3 :  [7, 16, 33, 34]\n",
      "4 :  [8, 17, 35, 36]\n",
      "5 :  [8, 18, 37, 38]\n",
      "6 :  [9, 19, 39, 40]\n",
      "7 :  [9, 20, 41, 42]\n",
      "8 :  [10, 21, 43, 44]\n",
      "9 :  [10, 22, 45, 46]\n",
      "10 :  [11, 23, 47, 48]\n",
      "11 :  [11, 24, 49, 50]\n",
      "12 :  [12, 25, 51, 52]\n",
      "13 :  [12, 26, 53, 54]\n",
      "14 :  [13, 27, 55, 56]\n",
      "15 :  [13, 28, 57, 58]\n",
      "16 :  [14, 29, 59, 60]\n",
      "17 :  [14, 30, 61, 62]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G_balanced = nx.balanced_tree(2,5)\n",
    "calculate_and_draw(G_balanced)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}