small-worldness.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "#print(nx.__version__)\n",
    "import csv\n",
    "import community\n",
    "import pandas as pd\n",
    "from itertools import combinations\n",
    "import itertools\n",
    "from matplotlib import pyplot as plt\n",
    "#create an empty graph\n",
    "G = nx.Graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the CSV file and read the data for languages\n",
    "with open('dataset/languages.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    for i, row in enumerate(reader):\n",
    "        if i == 0: # Skip the header columns\n",
    "            continue\n",
    "        # Add the language node to graph with green color\n",
    "        G.add_node(row[0], language=row[1], color='#30FBD0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create nodes and edges bewtween repositories and languages\n",
    "with open('dataset/repos.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    for i, row in enumerate(reader):\n",
    "        if i == 0: # Skip the header columns\n",
    "            continue\n",
    "        # transform the string of languages into an array of strings\n",
    "        row[2], row[5], row[6] = tuple(x.replace(' ', '').replace('[', '').replace(']', '').replace('\\'', '').replace('\"', '').split(',') for x in (row[2], row[5], row [6]))\n",
    "        G.add_node(row[0], name=row[1], topics=row[2], n_star=row[3], n_fork=row[4], languages=row[5], p_lang=row[6], color='#5D7EF5')\n",
    "        # Add the edges between the repository and the languages\n",
    "        #for lang in row[5]:\n",
    "         #   G.add_edge(row[0], lang)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create nodes and edges between users and repositories\n",
    "with open('dataset/users.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    for i, row in enumerate(reader):\n",
    "        if i == 0: # Skip the header columns\n",
    "            continue\n",
    "        # transform the string of repositories into an array of strings\n",
    "        row[2:4] = [x.replace(' ', '').replace('[', '').replace(']', '').replace('\\'', '').replace('\"', '').split(',') for x in row[2:4]]\n",
    "        # Add the user node to graph with blue color\n",
    "        G.add_node(row[0], name=row[1], repos=row[2], commits= row[3], color='#F8A643')\n",
    "        # Add edges between the user and their repositories\n",
    "        #for repo in row[2]:\n",
    "         #   G.add_edge(row[0], repo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add edges between users and repositories based on the users' list of repositories\n",
    "for node in list(G.nodes):\n",
    "    # if it's a user node\n",
    "    if len(node) >= 1:\n",
    "        if node[0] == \"u\":\n",
    "            # for each repository in the user's list of repositories\n",
    "            for repo in G.nodes[node]['repos']:\n",
    "                # add an edge between the user and the repository\n",
    "                G.add_edge(node, repo)\n",
    "        if node[0] == \"r\":\n",
    "            # for each language in the repository's list of languages\n",
    "            for lang in G.nodes[node]['languages']:\n",
    "                # add an edge between the repository and the language\n",
    "                G.add_edge(node, lang)     \n",
    "\n",
    "#nx.info(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Creazione del sottografo contenente solo utenti che hanno contribuito alla stessa repository\n",
    "users_subgraph = nx.Graph()\n",
    "for repo_node in G.nodes():\n",
    "    if repo_node.startswith('r'):\n",
    "        # Trova la lista degli utenti che hanno contribuito a questo repository\n",
    "        repo_users = [node for node in G.neighbors(repo_node) if node.startswith('u')]\n",
    "        # Aggiunge gli utenti e gli archi al sottografo\n",
    "        for u, v in itertools.combinations(repo_users, 2):\n",
    "            users_subgraph.add_edge(u, v)\n",
    "\n",
    "#nx.info(users_subgraph)\n",
    "#nx.edges(users_subgraph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering coefficient:  0.6263838145981003\n"
     ]
    }
   ],
   "source": [
    "#calculate clustering coefficient of users subgraph\n",
    "clustering_coefficient = nx.average_clustering(users_subgraph)\n",
    "print(\"Clustering coefficient: \", clustering_coefficient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Connected:  False\n"
     ]
    }
   ],
   "source": [
    "# view if the subgraph is connected\n",
    "conn = nx.is_connected(users_subgraph)\n",
    "print(\"Connected: \", conn)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#convert the graph to a directed graph\n",
    "users_subgraph_d = users_subgraph.to_directed()\n",
    "def average_shortest_path_length(users_subgraph_d):\n",
    "    # compute the strongly connected components of the graph\n",
    "    components = nx.strongly_connected_components(users_subgraph_d)\n",
    "\n",
    "    # compute the average shortest path length for each component\n",
    "    avg_shortest_path_lengths = []\n",
    "    for component in components:\n",
    "        subgraph = users_subgraph_d.subgraph(component)\n",
    "        avg_shortest_path_length = nx.average_shortest_path_length(subgraph)\n",
    "        avg_shortest_path_lengths.append(avg_shortest_path_length)\n",
    "\n",
    "    # compute the overall average shortest path length\n",
    "    overall_avg_shortest_path_length = sum(avg_shortest_path_lengths) / len(avg_shortest_path_lengths)\n",
    "\n",
    "    # print the results\n",
    "    return overall_avg_shortest_path_length, avg_shortest_path_lengths\n",
    "\n",
    "def average_degree(users_subgraph_d):\n",
    "    degree_sequence = sorted([d for n, d in users_subgraph_d.degree()], reverse=True)\n",
    "    degree_count = nx.degree_histogram(users_subgraph_d)\n",
    "    \n",
    "    return degree_count\n",
    "\n",
    "def sigma(clustering_coefficient1, clustering_coefficient2, average_shortest_path_length1, average_shortest_path_length2):\n",
    "    return (clustering_coefficient1 / clustering_coefficient2) / (average_shortest_path_length1 / average_shortest_path_length2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average shortest path length of users graph:  1.1174848059841047\n"
     ]
    }
   ],
   "source": [
    "overall_avg_shortest_path_length,avg_shortest_path_lengths = average_shortest_path_length(users_subgraph_d)\n",
    "print(\"average shortest path length of users graph: \", overall_avg_shortest_path_length)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scale-free"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average degree of users graph:  [0, 0, 45, 0, 15, 0, 10, 0, 7, 0, 25, 0, 8, 0, 9, 0, 8, 0, 1, 0, 10, 0, 0, 0, 1, 0, 0, 0, 1]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "average_degree_users = average_degree(users_subgraph_d) \n",
    "print(\"average degree of users graph: \", average_degree_users)\n",
    "\n",
    "# plot the degree distribution with bar chart whit log scale\n",
    "plt.bar(range(len(average_degree_users)), average_degree_users, align='center')\n",
    "plt.yscale('log')\n",
    "plt.title(\"Degree distribution of users\")\n",
    "plt.ylabel(\"Frequency\")\n",
    "plt.xlabel(\"Degree\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating best minimal value for power law fit\n",
      "alpha: 24.130577413051153\n"
     ]
    }
   ],
   "source": [
    "import powerlaw\n",
    "degrees = [users_subgraph_d.degree(n) for n in users_subgraph_d.nodes()]\n",
    "fit = powerlaw.Fit(degrees)\n",
    "alpha = fit.alpha\n",
    "print(\"alpha:\", alpha)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Small-worldness and random graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Small-worldness and random graphs\n",
    "m = users_subgraph.number_of_edges()\n",
    "n = users_subgraph.number_of_nodes()\n",
    "p = m / (n*(n-1)/2)  # probability of having an edge between any two nodes\n",
    "graph_er = nx.erdos_renyi_graph(len(users_subgraph_d), p, directed=True)\n",
    "\n",
    "#nx.info(graph_er)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering coefficient normal graph  0.6263838145981003\n",
      "Clustering coefficient of Erdos-Renyi graph:  0.02791144779590155\n"
     ]
    }
   ],
   "source": [
    "print(\"Clustering coefficient normal graph \", clustering_coefficient)\n",
    "clustering_coefficient_er = nx.average_clustering(graph_er)\n",
    "print(\"Clustering coefficient of Erdos-Renyi graph: \", clustering_coefficient_er)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average shortest path length of normal graph:  1.1174848059841047\n",
      "average shortest path length of ER user graph:  0.7385403050108932\n"
     ]
    }
   ],
   "source": [
    "print(\"average shortest path length of normal graph: \", overall_avg_shortest_path_length)\n",
    "# calculate the average shortest path length of the ER graph\n",
    "overall_avg_shortest_path_length_er,avg_shortest_path_lengths_er= average_shortest_path_length(graph_er)\n",
    "print(\"average shortest path length of ER user graph: \", overall_avg_shortest_path_length_er)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigma of users graph:  14.8316933397066\n"
     ]
    }
   ],
   "source": [
    "sigma = sigma(clustering_coefficient,clustering_coefficient_er,overall_avg_shortest_path_length,overall_avg_shortest_path_length_er)\n",
    "print(\"sigma of users graph: \", sigma)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Omega"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "omega of users graph:  -1.558664211986191\n"
     ]
    }
   ],
   "source": [
    "# Calculate the equivalent lattice network with the same number of nodes and edges as the original graph\n",
    "n = len(users_subgraph_d.nodes())\n",
    "k = len(users_subgraph_d.edges()) // n  # The average degree of the original graph\n",
    "p = clustering_coefficient / k  # The probability of rewiring edges\n",
    "lattice = nx.watts_strogatz_graph(n, k, p)\n",
    "\n",
    "# Calculate the average shortest path length and clustering coefficient of the lattice network\n",
    "lattice_avg_shortest_path_length = nx.average_shortest_path_length(lattice)\n",
    "lattice_clustering_coefficient = nx.average_clustering(lattice)\n",
    "\n",
    "omega = ((overall_avg_shortest_path_length_er/overall_avg_shortest_path_length) - (clustering_coefficient/lattice_clustering_coefficient))\n",
    "\n",
    "print(\"omega of users graph: \", omega)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original graph does not exhibit small-worldness.\n"
     ]
    }
   ],
   "source": [
    "# Determine the small-worldness of the original graph\n",
    "if lattice_avg_shortest_path_length < overall_avg_shortest_path_length and lattice_clustering_coefficient > clustering_coefficient:\n",
    "    print(\"The original graph exhibits small-worldness.\")\n",
    "else:\n",
    "    print(\"The original graph does not exhibit small-worldness.\")"
   ]
  }
 ],
 "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.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}