Optimally partitioning signed networks based on generalized balance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The graph partitioning algorithms based on the two mathematical programming models (Aref and Neal 2021) for optimally partitioning signed networks based on generalized balance and computing the exact values of k-clusterability index and clusterability index.\n",
    "\n",
    "These algorithms are written in Python 3.8 based on the two graph optimization models discussed in Aref and Neal (2021).\n",
    "\n",
    "Binary linear programming models for partitioning signed graphs based on generalized balance theory and computing the exact values of k-clusterability index and clusterability index - Jupyter code written by Samin Aref in 2019 and revised in 2022\n",
    "\n",
    "Creative common license: Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)\n",
    "\n",
    "Using this code for non-commercial purposes is permitted to all given that the following publication is cited:\n",
    "\n",
    "Aref, S., and Neal, Z.P., \"Identifying hidden coalitions in the US House of Representatives by optimally partitioning signed networks based on generalized balance\" (2021) Scientific Reports.\n",
    "\n",
    "Related dataset and R code repository (for further analysis of the optimal partitions):\n",
    "\n",
    "Neal, Z.P. and Aref, S., \"Frustrated Legislators: Replication data and code\" Figshare research data repository (2021). https://doi.org/10.17605/OSF.IO/3QTFB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suggested articles and other relevant datasets:\n",
    "\n",
    "    Aref, S, Mason, AJ, Wilson, MC. A modeling and computational study of the frustration index in signed networks. Networks. 2020; 75: 95– 110. url: https://doi.org/10.1002/net.21907\n",
    "\n",
    "\n",
    "    Aref, S., Mason, A. J., and Wilson, M. C., Computing the line index of balance using integer programming optimisation. In Optimization Problems in Graph Theory, B. Goldengorin, Ed. Springer, 2018, pp. 65-84. url: https://doi.org/10.1007/978-3-319-94830-0_3\n",
    "\n",
    "\n",
    "    Aref, S., and Neal, Z., Detecting Coalitions by Optimally Partitioning Signed Networks of Political Collaboration. Scientific Reports (2020). url: http://arxiv.org/pdf/1906.01696.\n",
    "\n",
    "\n",
    "    Aref, S., and Wilson, M. C. Balance and frustration in signed networks. Journal of Complex Networks 7, 2 (2019), 163–189. doi: 10.1093/comnet/cny015.\n",
    "    \n",
    "    \n",
    "    Aref, S., and Wilson, M. C. Measuring partial balance in signed networks. Journal of Complex Networks 6, 4 (2018), 566-595. doi: 10.1093/comnet/cnx044. \n",
    "    \n",
    "    \n",
    "    Aref, S. Signed networks from sociology and political science, systems biology, international relations, finance, and computational chemistry. Figshare research data repository (2017). doi: 10.6084/m9.figshare.5700832.v2.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Downloading the network data\n",
    "The 19 signed networks of the US House can be downloaded from the following repository as a zip file (network_data.zip) which can then be extracted and read from your local storage in the next chunk of code.\n",
    "Neal, Z.P. and Aref, S., \"Frustrated Legislators: Replication data and code\" Figshare research data repository (2021). https://doi.org/10.17605/OSF.IO/3QTFB\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start session (inclusive)? (97,98,...,115)97\n",
      "End session (exclusive)? (98,99,...,116)98\n",
      "Signed network for session 97 is generated\n"
     ]
    }
   ],
   "source": [
    "# Loading signed graphs from CSV files\n",
    "# Each file is one graph which becomes one instance for the\n",
    "# optimization model\n",
    "\n",
    "# Change 'path' based on the directory where you have copied \n",
    "# the network data (csv files of US House networks from Aref and Neal 2021)\n",
    "\n",
    "import networkx as nx\n",
    "import csv\n",
    "import numpy as np\n",
    "\n",
    "Graph=[]\n",
    "signedMatrix=[]\n",
    "unsignedMatrix=[]\n",
    "sorted_weighted_edges=[]\n",
    "order=[]\n",
    "size=[]\n",
    "NumberOfNegative=[]\n",
    "\n",
    "path='network_data\\\\'\n",
    "\n",
    "chamber='H' #for House of Representatives\n",
    "\n",
    "start_year=int(input(\"Start session (inclusive)? (97,98,...,115)\"))\n",
    "end_year=int(input(\"End session (exclusive)? (98,99,...,116)\"))\n",
    "\n",
    "run=end_year-start_year\n",
    "\n",
    "for i in range(run):\n",
    "\n",
    "    matrix=np.loadtxt(open(path+chamber.upper()+str(i+start_year)+\".csv\", \"rb\"), delimiter=\",\", skiprows=1)\n",
    "    order.append(len(np.matrix(matrix)))\n",
    "    \n",
    "    signedMatrix.append(np.matrix(matrix))\n",
    "    unsignedMatrix.append(abs(np.matrix(matrix)))\n",
    "\n",
    "    Graph.append(nx.from_numpy_matrix(signedMatrix[i]))\n",
    "    sorted_weighted_edges.append(nx.get_edge_attributes(Graph[i], 'weight'))\n",
    "\n",
    "    size.append(int(np.count_nonzero(signedMatrix[i]))/2)\n",
    "    NumberOfNegative.append(((-1 == signedMatrix[i])).sum()/2)\n",
    "    \n",
    "    print(\"Signed network for session\",i+start_year,\"is generated\")       \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n\n",
      "447\n",
      "m\n",
      "4954.0\n",
      "m-\n",
      "4494.0\n"
     ]
    }
   ],
   "source": [
    "# Sanity check to make sure the signed networks are loaded correctly\n",
    "# The numbers printed must match the numbers in Table S1 of the \n",
    "# Scientific Reports article (Aref and Neal 2021)\n",
    "\n",
    "print(\"n\")\n",
    "for index in range(run):\n",
    "    print(order[index])   \n",
    "\n",
    "print(\"m\")    \n",
    "for index in range(run):\n",
    "    print(size[index])\n",
    "    \n",
    "print(\"m-\")\n",
    "for index in range(run):\n",
    "    print(NumberOfNegative[index])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is the predefined number of clusters?7\n",
      "Set parameter Threads to value 16\n",
      "Set parameter NodefileStart to value 0.5\n",
      "Gurobi Optimizer version 9.5.2 build v9.5.2rc0 (win64)\n",
      "Thread count: 8 physical cores, 16 logical processors, using up to 16 threads\n",
      "Optimize a model with 35132 rows, 102810 columns and 110292 nonzeros\n",
      "Model fingerprint: 0x37e84e42\n",
      "Variable types: 0 continuous, 102810 integer (102810 binary)\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 1e+00]\n",
      "  Objective range  [1e+00, 1e+00]\n",
      "  Bounds range     [1e+00, 1e+00]\n",
      "  RHS range        [1e+00, 1e+00]\n",
      "Found heuristic solution: objective 1015.0000000\n",
      "Presolve removed 0 rows and 94727 columns\n",
      "Presolve time: 0.09s\n",
      "Presolved: 35132 rows, 8083 columns, 110292 nonzeros\n",
      "Variable types: 0 continuous, 8083 integer (8083 binary)\n",
      "\n",
      "Root relaxation: objective 0.000000e+00, 2914 iterations, 0.32 seconds (0.93 work units)\n",
      "\n",
      "    Nodes    |    Current Node    |     Objective Bounds      |     Work\n",
      " Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time\n",
      "\n",
      "     0     0    0.00000    0  522 1015.00000    0.00000   100%     -    1s\n",
      "H    0     0                     164.0000000    0.00000   100%     -    1s\n",
      "H    0     0                      93.0000000    0.00000   100%     -    3s\n",
      "H    0     0                      52.0000000    0.00000   100%     -    3s\n",
      "     0     0    0.00000    0  855   52.00000    0.00000   100%     -    3s\n",
      "H    0     0                      51.0000000    0.00000   100%     -    4s\n",
      "H    0     0                       4.0000000    0.00000   100%     -    8s\n",
      "     0     0    0.00000    0  450    4.00000    0.00000   100%     -    8s\n",
      "     0     0    0.33333    0  752    4.00000    0.33333  91.7%     -   11s\n",
      "     0     0    0.33333    0  749    4.00000    0.33333  91.7%     -   11s\n",
      "     0     0    0.90278    0 1228    4.00000    0.90278  77.4%     -   14s\n",
      "     0     0    0.90278    0 1230    4.00000    0.90278  77.4%     -   14s\n",
      "     0     0    1.00000    0 1061    4.00000    1.00000  75.0%     -   15s\n",
      "     0     0    1.00000    0  984    4.00000    1.00000  75.0%     -   17s\n",
      "     0     2    1.00000    0  968    4.00000    1.00000  75.0%     -   21s\n",
      "    24     4    1.00000    5 1160    4.00000    1.00000  75.0%  1652   25s\n",
      "\n",
      "Cutting planes:\n",
      "  MIR: 2\n",
      "  Zero half: 114\n",
      "  RLT: 9\n",
      "  BQP: 192\n",
      "\n",
      "Explored 32 nodes (126734 simplex iterations) in 27.30 seconds (93.19 work units)\n",
      "Thread count was 16 (of 16 available processors)\n",
      "\n",
      "Solution count 6: 4 51 52 ... 1015\n",
      "\n",
      "Optimal solution found (tolerance 1.00e-04)\n",
      "Best objective 4.000000000000e+00, best bound 4.000000000000e+00, gap 0.0000%\n",
      "Model 97 solve time: 27.30527949333191\n",
      "Model 97  optimal solution equals 4.0\n",
      "Clusterability indices ( k= 7 ): [4.0]\n",
      "Solve times: [27.31]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Partitioning based on generalized balance for a given predefined\n",
    "# number of clusters (the parameter maximum_colour)\n",
    "\n",
    "# Forcing the exact number of predefined clusters to be used\n",
    "\n",
    "# Solves multiple instances based on the number of input graphs\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import multiprocessing\n",
    "import copy\n",
    "import time\n",
    "from gurobipy import *\n",
    "maximum_colour=int(input(\"What is the predefined number of clusters?\"))\n",
    "objectivevalue=[]\n",
    "solveTime=[]\n",
    "effectiveBranchingFactors=[]\n",
    "optimal_partition=[]\n",
    "\n",
    "for index in range(run):\n",
    "\n",
    "    degree=(signedMatrix[index]).sum(1)\n",
    "    unsignedDegree=(unsignedMatrix[index]).sum(1)\n",
    "\n",
    "    x=[]\n",
    "    f={}\n",
    "\n",
    "    # Model\n",
    "    model = Model(\"Multi-colour frustration\")\n",
    "    \n",
    "    # How many threads to be used for exploring the feasible space in parallel?\n",
    "    # Here, the minimum of 32 and the availbale CPUs is used\n",
    "    model.setParam(GRB.Param.Threads, min(32,multiprocessing.cpu_count()))\n",
    "    \n",
    "    # Do you want details of branching to be reported? (0=No, 1=Yes)\n",
    "    model.setParam(GRB.param.OutputFlag, 1) \n",
    "    \n",
    "    # For large MIPs and limited RAM, it is suggested to set this parameter for writing search tree nodes on disk\n",
    "    model.setParam(\"NodefileStart\", 0.5)\n",
    "    \n",
    "    # Do you want a non-zero Mixed integer programming tolerance (MIP Gap)?\n",
    "    # Note that a non-zero MIP gap may prevent the model from computing the exact value of frustration index\n",
    "    # model.setParam('MIPGap', 0.175)  \n",
    "    \n",
    "    # There are different methods for solving optimization models:\n",
    "    # (-1=automatic, 0=primal simplex, 1=dual simplex, 2=barrier, 3=concurrent, 4=deterministic concurrent)\n",
    "    # For problems with a large number of contstraints, barrier method is more suitable\n",
    "    #model.setParam(GRB.param.Method, -1)\n",
    "\n",
    "    # Creating the decision variables\n",
    "    for i in range(0,order[index]):\n",
    "        x.append([])\n",
    "        for c in range(maximum_colour):\n",
    "            x[i].append(model.addVar(lb=0.0, ub=1, vtype=GRB.BINARY, name='x'+str(i)+','+str(c))) # arguments by name\n",
    "\n",
    "    for (i,j) in (sorted_weighted_edges[index]):\n",
    "            f[(i,j)]=model.addVar(lb=0.0, ub=1, vtype=GRB.BINARY, name='f'+str(i)+','+str(j))\n",
    "\n",
    "    # Updating the model to integrate new variables\n",
    "    model.update()\n",
    "    \n",
    "    OFV=0        \n",
    "    for (i,j) in (sorted_weighted_edges[index]):\n",
    "        OFV = OFV + f[(i,j)]              \n",
    "    model.setObjective(OFV, GRB.MINIMIZE)\n",
    "\n",
    "    # Adding constraints to the model\n",
    "    for c in range(maximum_colour):\n",
    "        for (i,j) in (sorted_weighted_edges[index]):\n",
    "            if (sorted_weighted_edges[index])[(i,j)]==1:\n",
    "                model.addConstr( f[(i,j)] >= x[i][c] - x[j][c]  , 'posEdge'+','+str(i)+','+str(j))       \n",
    "            if (sorted_weighted_edges[index])[(i,j)]==-1:\n",
    "                model.addConstr( f[(i,j)] >= x[i][c] + x[j][c] -1  , 'negEdge'+','+str(i)+','+str(j))\n",
    "\n",
    "    # Constraint to ensure every node takes a color.\n",
    "    for i in range (0,order[index]):\n",
    "         model.addConstr(gurobipy.quicksum((x[i][c] for c in range(maximum_colour))) == 1)\n",
    "            \n",
    "    # Additional constraint to force all colors to be used\n",
    "    for c in range(maximum_colour):\n",
    "         model.addConstr(gurobipy.quicksum((x[i][c] for i in range(order[index]))) >= 1)\n",
    "    \n",
    "    #model.addConstr(OFV >= 200, 'LP lower bound')    \n",
    "    model.update()\n",
    " \n",
    "\n",
    "    # Solving the mathematical optimization model\n",
    "    start_time = time.time()\n",
    "    model.optimize()\n",
    "    solveTime.append(time.time() - start_time) \n",
    "    print('Model', index+start_year,\"solve time:\",(time.time() - start_time))\n",
    "    \n",
    "    obj = model.getObjective()\n",
    "    objectivevalue.append((obj.getValue()))\n",
    "    print('Model', index+start_year,' optimal solution equals',objectivevalue[index]) \n",
    "    \n",
    "    \n",
    "    # Constructing the optimal partition based on the optimal solution\n",
    "    optimal_partition.append([])\n",
    "    for v in model.getVars():\n",
    "        if v.varName.startswith('x'):\n",
    "            if v.x>0.9:\n",
    "                (optimal_partition[index]).append(int(v.varName[-1]))\n",
    "                #print (v.varName, v.x)   \n",
    "    #for color in optimal_partition[index]:\n",
    "    #    print(color)\n",
    "    \n",
    "print(\"Clusterability indices ( k=\",maximum_colour,\"):\",objectivevalue)\n",
    "#print(\"frustrarion index Average\",np.mean(objectivevalue))\n",
    "#print(\"Frustration index SD     \",np.std(objectivevalue))\n",
    "print(\"Solve times:\",np.around(solveTime, decimals=2))\n",
    "#print(\"Average solve time\",np.mean(solveTime))\n",
    "#print(\"Solve time Standard Deviation\",np.std(solveTime))\n",
    "print()\n",
    "#for index in range(run):\n",
    "#    print(objectivevalue[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving the optimal partitions as one row for each network in a csv file\n",
    "\n",
    "import pandas as pd\n",
    "df_save = pd.DataFrame(optimal_partition)\n",
    "df_save.to_csv('optimal_'+str(maximum_colour)+'_partitions.csv', index=False, header=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many random graphs do you want to create?(1/2/...)2\n",
      "\n",
      " 1.  Erdős-Rényi binomial graph G_{n,p} \n",
      " 2.  Random graph of n nodes and m total edges G_{n,m} \n",
      " 3.  Newman-Watts-Strogatz small world graph (adding new edges to the ring) G_{n,k,p} \n",
      " 4.  Watts-Strogatz small world graph (rewiring the ring) G_{n,k,p} \n",
      " 5.  Random regular graph of n nodes each with degree d G_{d,n} \n",
      " 6.  Barabási-Albert preferential attachment model graph G_{n,m} \n",
      " 7.  Growing graph with powerlaw degree distribution and approximate average clustering G_{n,m,p}\n",
      " 8.  Two-dimensional grid n*n \n",
      "What type of random graph(s) do you want to create from the list above? (1/2/...)2\n",
      "What is the number of nodes?20\n",
      "What is the total number of edges?100\n",
      "What is the number of negative edges for this instance? (0/1/2/.../m)50\n",
      "What is the number of nodes?40\n",
      "What is the total number of edges?200\n",
      "What is the number of negative edges for this instance? (0/1/2/.../m)150\n"
     ]
    }
   ],
   "source": [
    "# This code is for producing synthetic data (generating random \"signed graphs\")\n",
    "# \"Signed graphs\" are graphs in which edges are postive or negative (signed)\n",
    "# This code asks you for type of random graph, several parameters for generating them such as size and order\n",
    "# and then it asks for \"number of negative edges\" so that it randomly makes some edges negative and produce \n",
    "# a signed graph out of an unsigned graph\n",
    "\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "start_year=0\n",
    "\n",
    "listOfGraphs=[]\n",
    "NumberOfNegative=[]\n",
    "run=int(input(\"How many random graphs do you want to create?(1/2/...)\"))\n",
    "\n",
    "print(\"\\n 1.  Erdős-Rényi binomial graph G_{n,p} \"\n",
    "      \"\\n 2.  Random graph of n nodes and m total edges G_{n,m} \"\n",
    "      \"\\n 3.  Newman-Watts-Strogatz small world graph (adding new edges to the ring) G_{n,k,p} \"\n",
    "      \"\\n 4.  Watts-Strogatz small world graph (rewiring the ring) G_{n,k,p} \"\n",
    "      \"\\n 5.  Random regular graph of n nodes each with degree d G_{d,n} \"\n",
    "      \"\\n 6.  Barabási-Albert preferential attachment model graph G_{n,m} \"\n",
    "      \"\\n 7.  Growing graph with powerlaw degree distribution and approximate average clustering G_{n,m,p}\"\n",
    "      \"\\n 8.  Two-dimensional grid n*n \")\n",
    "\n",
    "graph_type=int(input(\"What type of random graph(s) do you want to create from the list above? (1/2/...)\"))\n",
    "\n",
    "for i in range(run):\n",
    "\n",
    "    if graph_type == 1:\n",
    "        n=int(input(\"What is the number of nodes?\"))\n",
    "        p=float(input(\"What is the probability of having an edge for each two nodes? (0.1, 0.5, ...)\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.fast_gnp_random_graph(n,p)\n",
    "        listOfGraphs.append(G) \n",
    "    elif graph_type == 2:\n",
    "        n=int(input(\"What is the number of nodes?\"))\n",
    "        m=int(input(\"What is the total number of edges?\"))  \n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.gnm_random_graph(n,m)\n",
    "        listOfGraphs.append(G)\n",
    "    elif graph_type == 3:\n",
    "        n=int(input(\"What is the number of nodes?\"))\n",
    "        k=int(input(\"What is the number of nearest neighbors in ring topology?\"))\n",
    "        p=float(input(\"What is the probability of adding a new edge?\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.newman_watts_strogatz_graph(n,k,p)\n",
    "        listOfGraphs.append(G)\n",
    "    elif graph_type == 4:\n",
    "        n=int(input(\"What is the number of nodes?\"))\n",
    "        k=int(input(\"What is the number of nearest neighbors in ring topology?\"))\n",
    "        p=float(input(\"What is the probability of rewiring each edge?\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.watts_strogatz_graph(n,k,p)\n",
    "        listOfGraphs.append(G)\n",
    "    elif graph_type == 5:\n",
    "        n=int(input(\"What is the number of nodes?(n>d)\"))\n",
    "        d=int(input(\"What is the degree?(The value of n*d must be even)\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.random_regular_graph(d,n)\n",
    "        listOfGraphs.append(G)\n",
    "    elif graph_type == 6:\n",
    "        n=int(input(\"What is the number of nodes?\"))\n",
    "        m=int(input(\"What is the number of edges to attach from a new node to existing nodes?\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.barabasi_albert_graph(n,m)   \n",
    "        listOfGraphs.append(G)\n",
    "    elif graph_type == 7:\n",
    "        n=int(input(\"What is the number of nodes?\"))\n",
    "        m=int(input(\"What is the number of random edges to add for each new node?\"))\n",
    "        p=float(input(\"What is the probability of adding a triangle after adding a random edge?\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.powerlaw_cluster_graph(n,m,p)    \n",
    "        listOfGraphs.append(G)\n",
    "    elif graph_type == 8:\n",
    "        n=int(input(\"What is the size of the grid?(sqrt(n))\"))\n",
    "        NumberOfNegative.append(int(input(\"What is the number of negative edges for this instance? (0/1/2/.../m)\")))\n",
    "        G=nx.grid_2d_graph(n,n)\n",
    "        mapping=dict(zip(G.nodes(),range(len(G.nodes()))))\n",
    "        G=nx.relabel_nodes(G,mapping)\n",
    "        listOfGraphs.append(G)\n",
    "    else:\n",
    "        print(\"Try again and choose a graph type from the selection above!\")\n",
    "\n",
    "                    \n",
    "Graph=[]\n",
    "signedMatrix=[]\n",
    "unsignedMatrix=[]\n",
    "ShuffledEdges=[]\n",
    "sorted_weighted_edges=[]\n",
    "size=[]\n",
    "order=[]\n",
    "\n",
    "\n",
    "for i in range(run):\n",
    "        ShuffledEdges = list(listOfGraphs[i].edges())\n",
    "        random.shuffle(ShuffledEdges)\n",
    "        Graph.append(nx.Graph())\n",
    "        for u in listOfGraphs[i].nodes():\n",
    "            Graph[i].add_node(u)\n",
    "        for ind in range(0,NumberOfNegative[i]):\n",
    "            (u,v) = ShuffledEdges[ind]\n",
    "            Graph[i].add_edge(u,v,weight=-1)\n",
    "        for ind in range(NumberOfNegative[i],len(listOfGraphs[i].edges())):\n",
    "            (u,v) = ShuffledEdges[ind]\n",
    "            Graph[i].add_edge(u,v,weight=1)\n",
    "        signedMatrix.append(nx.to_numpy_matrix(Graph[i]))\n",
    "        unsignedMatrix.append(abs(signedMatrix[i]))\n",
    "        ShuffledEdges=[]\n",
    "        size.append(int(np.count_nonzero(signedMatrix[i])/2))\n",
    "        order.append(int(len(signedMatrix[i])))\n",
    "\n",
    "        weighted_edges=nx.get_edge_attributes(Graph[i], 'weight') \n",
    "        sorted_weighted_edges.append({})\n",
    "        for (u,v) in weighted_edges:\n",
    "            if u<v:\n",
    "                (sorted_weighted_edges[i])[(u,v)] = weighted_edges[(u,v)]\n",
    "            if u>v:\n",
    "                (sorted_weighted_edges[i])[(v,u)] = weighted_edges[(u,v)]          \n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualizing the random signed network created in the previous step\n",
    "# (visualizing the i-th network, if created multiple signed network)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "i=0\n",
    "\n",
    "w=nx.get_edge_attributes(Graph[i], 'weight')\n",
    "positive_edges=[]\n",
    "for (u,v) in Graph[i].edges():\n",
    "    if w[(u,v)]==1:\n",
    "        positive_edges.append((u,v))\n",
    "negative_edges=[]\n",
    "for (u,v) in Graph[i].edges():\n",
    "    if w[(u,v)]== -1:\n",
    "        negative_edges.append((u,v))\n",
    "\n",
    "pos = nx.circular_layout(Graph[i], dim=2, scale=1)\n",
    "nx.draw_networkx_nodes(Graph[i], pos, node_color='y')\n",
    "nx.draw_networkx_edges(Graph[i], pos, edgelist=positive_edges, edge_color='b', width=0.5, style='solid')\n",
    "nx.draw_networkx_edges(Graph[i], pos, edgelist=negative_edges, edge_color='r', width=0.25, style='dashed')\n",
    "#nx.draw_networkx_edges(Graph[i], pos, edgelist=frustrated_edges, style='dashdot')\n",
    "nx.draw_networkx_labels(Graph[i],pos,font_size=11,font_family='sans-serif')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set parameter Username\n",
      "Academic license - for non-commercial use only - expires 2023-06-30\n",
      "Set parameter Crossover to value 0\n",
      "Set parameter NodefileStart to value 0.5\n",
      "Set parameter Threads to value 16\n",
      "Gurobi Optimizer version 9.5.2 build v9.5.2rc0 (win64)\n",
      "Thread count: 8 physical cores, 16 logical processors, using up to 16 threads\n",
      "Optimize a model with 5608269 rows, 99681 columns and 16824807 nonzeros\n",
      "Model fingerprint: 0x6fe4d9a0\n",
      "Variable types: 0 continuous, 99681 integer (99681 binary)\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 1e+00]\n",
      "  Objective range  [1e+00, 1e+00]\n",
      "  Bounds range     [1e+00, 1e+00]\n",
      "  RHS range        [1e+00, 1e+00]\n",
      "Found heuristic solution: objective 383.0000000\n",
      "Presolve removed 0 rows and 135 columns (presolve time = 5s) ...\n",
      "Presolve removed 45 rows and 135 columns (presolve time = 10s) ...\n",
      "Presolve removed 45 rows and 135 columns (presolve time = 15s) ...\n",
      "Presolve removed 45 rows and 135 columns\n",
      "Presolve time: 15.93s\n",
      "Presolved: 5608224 rows, 99546 columns, 16824672 nonzeros\n",
      "Variable types: 0 continuous, 99546 integer (99546 binary)\n",
      "Found heuristic solution: objective 333.0000000\n",
      "\n",
      "Deterministic concurrent LP optimizer: primal simplex, dual simplex, and barrier\n",
      "Showing barrier log only...\n",
      "\n",
      "Warning: Concurrent optimizer requires crossover - forcing it on\n",
      "Root barrier log...\n",
      "\n",
      "\n",
      "Barrier performed 0 iterations in 86.84 seconds (54.74 work units)\n",
      "Barrier solve interrupted - model solved by another algorithm\n",
      "\n",
      "Concurrent spin time: 54.63s (can be avoided by choosing Method=3)\n",
      "\n",
      "Solved with dual simplex\n",
      "\n",
      "Root relaxation: objective 4.000000e+00, 12143 iterations, 66.95 seconds (12.49 work units)\n",
      "\n",
      "    Nodes    |    Current Node    |     Objective Bounds      |     Work\n",
      " Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time\n",
      "\n",
      "*    0     0               0       4.0000000    4.00000  0.00%     -   87s\n",
      "\n",
      "Explored 1 nodes (12143 simplex iterations) in 87.52 seconds (54.76 work units)\n",
      "Thread count was 16 (of 16 available processors)\n",
      "\n",
      "Solution count 3: 4 333 383 \n",
      "\n",
      "Optimal solution found (tolerance 1.00e-04)\n",
      "Best objective 4.000000000000e+00, best bound 4.000000000000e+00, gap 0.0000%\n",
      "Instance 0 : clusterability index equals 4.0\n",
      "Groups: [['1', '5', '8', '11', '13', '14', '22', '29', '33', '40', '46', '49', '52', '54', '55', '56', '58', '64', '65', '70', '71', '78', '80', '81', '83', '86', '88', '89', '97', '100', '101', '103', '106', '109', '110', '119', '125', '127', '132', '133', '134', '136', '142', '149', '153', '155', '158', '159', '161', '162', '166', '174', '178', '181', '185', '188', '189', '204', '207', '209', '215', '216', '223', '224', '226', '232', '234', '241', '243', '244', '247', '251', '252', '257', '258', '259', '263', '264', '269', '270', '272', '274', '275', '279', '280', '283', '285', '290', '292', '295', '303', '304', '305', '306', '313', '315', '316', '327', '329', '330', '331', '332', '335', '336', '339', '340', '342', '346', '347', '357', '366', '367', '377', '390', '391', '393', '398', '402', '404', '409', '413', '415', '421', '424', '425', '428', '429', '433', '435', '438', '439', '443'], ['3', '4'], ['9', '18', '23', '24', '27', '31', '34', '35', '36', '38', '44', '47', '53', '57', '73', '74', '75', '79', '82', '84', '102', '112', '115', '128', '138', '140', '143', '148', '150', '156', '167', '168', '176', '179', '180', '184', '186', '200', '201', '211', '213', '230', '233', '245', '276', '286', '287', '308', '322', '325', '326', '334', '344', '345', '351', '353', '360', '363', '369', '372', '376', '382', '399', '406', '426', '436', '442', '446'], ['20', '410'], ['30', '62', '121', '214', '414', '437'], ['43', '328'], ['114', '294']]\n",
      "Non-collaborators: 233\n",
      "Number of collaborative groups: 7\n",
      "\n",
      "-------------------------------- ***  EXPERIMENT STATS  *** --------------------------------\n",
      "--------------------------------------------------------------------------------------------\n",
      "Clusterability indices: [4.0]\n",
      "Solve times: [87.57]\n"
     ]
    }
   ],
   "source": [
    "# Correlation clustering (generalized balance without specifying k,\n",
    "# the number of clusters)\n",
    "# This model is based on the formulation by Demaine et al.,\n",
    "# Correlation clustering in general weighted graphs. Theor. Comput.\n",
    "# Sci. 361, 172–187 (2006). \n",
    "# We have reformulated it such that the constraints are for a smaller\n",
    "# set of node triples. Therefore, it is more efficient \n",
    "# for possibly non-complete graphs and particularly for sparse graphs\n",
    "\n",
    "# Solves multiple instances based on the number of input graphs\n",
    "\n",
    "from itertools import combinations\n",
    "import time\n",
    "import copy\n",
    "import numpy as np\n",
    "import multiprocessing\n",
    "from gurobipy import *\n",
    "objectivevalue=[]\n",
    "solveTime=[]\n",
    "effectiveBranchingFactors=[]\n",
    "number_of_subsets=[]\n",
    "single_member=[]\n",
    "collaborative_groups=[]\n",
    "\n",
    "def find_in_list_of_list(mylist, char):\n",
    "    for sub_list in mylist:\n",
    "        if char in sub_list:\n",
    "            return (mylist.index(sub_list))\n",
    "    raise ValueError(\"'{char}' is not in list\".format(char = char))\n",
    "\n",
    "for index in range(run):\n",
    "\n",
    "    degree=(signedMatrix[index]).sum(1)\n",
    "    unsignedDegree=(unsignedMatrix[index]).sum(1)\n",
    "\n",
    "    x={}\n",
    "    clustered=[]\n",
    "\n",
    "    # Model\n",
    "    model = Model(\"Correlation clustering\")\n",
    "    # There are different methods for solving optimization models:\n",
    "    # (-1=automatic, 0=primal simplex, 1=dual simplex, 2=barrier, 3=concurrent, 4=deterministic concurrent)\n",
    "    # For problems with a large number of contstraints and sufficient RAM, barrier method is sometimes more suitable\n",
    "    model.setParam(GRB.param.Method, -1)\n",
    "    \n",
    "    # Solving the problems without crossover takes a substantially shorter time\n",
    "    # in cases where there are a large number of constraints. (0=without, 1=with)\n",
    "    model.setParam(GRB.Param.Crossover, 0)\n",
    "    \n",
    "    # For large MIPs and limited RAM, it is suggested to set this parameter for writing search tree nodes on disk\n",
    "    model.setParam(\"NodefileStart\", 0.5)\n",
    "    \n",
    "    # Do you want details of branching to be reported? (0=No, 1=Yes)\n",
    "    model.setParam(GRB.param.OutputFlag, 1) \n",
    "    \n",
    "    # How many threads to be used for exploring the feasible space in parallel?\n",
    "    # Here, the minimum of 64 and the availbale CPUs is used\n",
    "    model.setParam(GRB.Param.Threads, min(32,multiprocessing.cpu_count()))\n",
    "\n",
    "    # Create decision variables\n",
    "    # Note that there are variables for every pair of nodes i,j such that i<j\n",
    "    # The variable takes 1 iff i and j belong to the same group and it takes 0 otherwise\n",
    "    for i in (Graph[index]).nodes():\n",
    "        for j in filter(lambda x: x>i, (Graph[index]).nodes()):\n",
    "            x[(i,j)]=model.addVar(lb=0.0, ub=1, vtype=GRB.BINARY, name=str(i)+','+str(j))\n",
    "            if (i,j) not in sorted_weighted_edges[index]:\n",
    "                (sorted_weighted_edges[index])[(i,j)]=0\n",
    "\n",
    "    # Update model to integrate new variables\n",
    "    model.update()\n",
    "        \n",
    "    #This code lists all sorted triples of nodes (open and closed)\n",
    "    list_of_tuples=list(combinations(np.sort(list((Graph[index]).nodes())),3))\n",
    "    #list_of_triads=[list(elem) for elem in list_of_tuples]  #Using all triples is costly and not necessary\n",
    "    \n",
    "    list_of_triads=[]\n",
    "    for [i,j,k] in list_of_tuples:\n",
    "        if abs((sorted_weighted_edges[index])[(i,j)])+abs((sorted_weighted_edges[index])[(j,k)])+abs((sorted_weighted_edges[index])[(i,k)]) >= 1:\n",
    "            list_of_triads.append(np.sort([i,j,k]))\n",
    "    \n",
    "    # The term in the objective function for a pair of nodes without an edge is 0\n",
    "    # The term in the objective function for a positive edge is 1-xij\n",
    "    # The term in the objective function for a negative edge is xij\n",
    "    OFV=0\n",
    "\n",
    "    for (i,j) in (sorted_weighted_edges[index]):\n",
    "            OFV = OFV + ((sorted_weighted_edges[index])[(i,j)])*((((sorted_weighted_edges[index])[(i,j)])+1)/2)\\\n",
    "            -((sorted_weighted_edges[index])[(i,j)])*x[(i,j)] \n",
    "\n",
    "\n",
    "    model.setObjective(OFV, GRB.MINIMIZE)\n",
    "\n",
    "    # Add constraints to the model\n",
    "    for [i,j,k] in list_of_triads:\n",
    "        model.addConstr(x[(i,j)] + x[(i,k)] <= 1+x[(j,k)] , 'triangle1'+','+str(i)+','+str(j)+','+str(k))\n",
    "        model.addConstr(x[(i,j)] + x[(j,k)] <= 1+x[(i,k)] , 'triangle2'+','+str(i)+','+str(j)+','+str(k))       \n",
    "        model.addConstr(x[(j,k)] + x[(i,k)] <= 1+x[(i,j)] , 'triangle3'+','+str(i)+','+str(j)+','+str(k))\n",
    "    model.update()\n",
    "    \n",
    "    #model.addConstr(OFV <= int(UpperBounds[index]), 'LP Upper bound')\n",
    "    model.update()\n",
    "   \n",
    "    # Solve\n",
    "    start_time = time.time()\n",
    "    model.optimize()\n",
    "    solveTime.append(time.time() - start_time) \n",
    "    \n",
    "    obj = model.getObjective()\n",
    "    objectivevalue.append((obj.getValue()))\n",
    "    print('Instance',index,': clusterability index equals',objectivevalue[index]) \n",
    "    \n",
    "    \n",
    "    for v in model.getVars():\n",
    "    #if v.varName.startswith('x'):\n",
    "        if v.x!=0:\n",
    "            clustered.append((v.varName).split(\",\"))\n",
    "            #print (v.varName, v.x)\n",
    "            \n",
    "    #print(clustered)\n",
    "    \n",
    "    # Computing the number of subsets in the k-color solution\n",
    "\n",
    "    reduction=0\n",
    "    i=0\n",
    "    visited_endpoints=[]\n",
    "    group=[]\n",
    "    for pair in clustered:\n",
    "        if pair[0] not in visited_endpoints and pair[1] not in visited_endpoints:\n",
    "            reduction=reduction+1\n",
    "            visited_endpoints.append(pair[0])\n",
    "            visited_endpoints.append(pair[1])\n",
    "            group.append([])\n",
    "            (group[i]).append(pair[0])\n",
    "            (group[i]).append(pair[1])\n",
    "            i=i+1\n",
    "        if pair[0] not in visited_endpoints and pair[1] in visited_endpoints:\n",
    "            reduction=reduction+1\n",
    "            index_one=find_in_list_of_list(group, pair[1])\n",
    "            (group[index_one]).append(pair[0])\n",
    "            visited_endpoints.append(pair[0])\n",
    "        if pair[1] not in visited_endpoints and pair[0] in visited_endpoints:\n",
    "            reduction=reduction+1\n",
    "            index_zero=find_in_list_of_list(group, pair[0])\n",
    "            (group[index_zero]).append(pair[1])\n",
    "            visited_endpoints.append(pair[1])\n",
    "        if pair[0] in visited_endpoints and pair[1] in visited_endpoints:\n",
    "            index_zero=find_in_list_of_list(group, pair[0])\n",
    "            index_one=find_in_list_of_list(group, pair[1])\n",
    "            if index_zero!=index_one:\n",
    "                reduction=reduction+1\n",
    "                group[index_zero]=group[index_zero]+group[index_one]\n",
    "                del group[index_one]\n",
    "                i=i-1\n",
    "\n",
    "            \n",
    "    collaborative_groups.append(len(group))        \n",
    "    number_of_subsets.append(order[index]-reduction)\n",
    "    single_member.append(order[index]-len(visited_endpoints))\n",
    "\n",
    "    #print(\"reduction:\",reduction)\n",
    "    #print(\"visited endpoints:\",visited_endpoints)\n",
    "    print(\"Groups:\",group)\n",
    "    print(\"Non-collaborators:\",order[index]-len(visited_endpoints))\n",
    "    print(\"Number of collaborative groups:\",len(group))\n",
    "    #print(\"Number of subsets:\",order[index]-reduction)\n",
    "    print()\n",
    "\n",
    "    \n",
    "print(\"-\"*32,\"***  EXPERIMENT STATS  ***\",\"-\"*32)\n",
    "print(\"-\"*92)         \n",
    "    \n",
    "print(\"Clusterability indices:\",objectivevalue)\n",
    "#print(\"Clusterability index Average\",np.mean(objectivevalue))\n",
    "#print(\"Clusterability index SD     \",np.std(objectivevalue))\n",
    "print(\"Solve times:\",np.around(solveTime, decimals=2))\n",
    "#print(\"Average solve time\",np.mean(solveTime))\n",
    "#print(\"Solve time Standard Deviation\",np.std(solveTime))\n",
    "\n",
    "\n",
    "#print(\"Q_k\")\n",
    "#for index in range(run):\n",
    "#    print(objectivevalue[index])\n",
    "#print(\"Collaborative groups\")\n",
    "#for index in range(run):\n",
    "#    print(collaborative_groups[index])\n",
    "#print(\"Non-collaborators count\")\n",
    "#for index in range(run):\n",
    "#    print(single_member[index])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}