From 5c70ff3a199eecf612c08f9d9429880bdeade3ad Mon Sep 17 00:00:00 2001 From: Luca Lombardo Date: Wed, 8 Feb 2023 14:56:26 +0100 Subject: [PATCH] almost final version, need to review the theory --- .gitignore | 1 + analysis_results.pkl | Bin 1865 -> 1790 bytes main.ipynb | 3214 +++++++++++++++++++++------------------ omega_sampled_server.py | 13 +- testing.ipynb | 846 ++--------- utils.py | 102 +- 6 files changed, 1924 insertions(+), 2252 deletions(-) diff --git a/.gitignore b/.gitignore index 57eeefa..8c523ca 100644 --- a/.gitignore +++ b/.gitignore @@ -147,3 +147,4 @@ data/ backup/ sources/ extra/ +html_graphs/ diff --git a/analysis_results.pkl b/analysis_results.pkl index b9a1193771ada1fc07cc369235eb22008b9b4479..2fb5818049821a4a03fc4c7d1b319a41473e5ca7 100644 GIT binary patch delta 456 zcmX@f_m7vgfpzLs*k(95bLcp{GZml2HTf%(nZTCXQnzJ{%)c^oz{HRU< delta 531 zcmeyzdyqH%|>TvD*(>$YaHYlQH{Uk%iVDU!}--Arx8Y^La9KHXJ~k{d2@I(0>dU^ ziZ>G|h%&e{Vl<{1FhBs;^~D9YT*vqCkZXM%xZ~XZ%9m<}9BbC>pEVN%PVR@Oy0HK7 xSB;qdLr3>d$#C#y1P5et3CJ)FZ;r|GtaglxCdaXUW?V8kh)thy$K)oq8UTmz)g1r; diff --git a/main.ipynb b/main.ipynb index 234c4db..f067967 100644 --- a/main.ipynb +++ b/main.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -57,12 +57,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Background theory: The Erdős-Rényi model\n", + "# Random Networks: The Erdős-Rényi model\n", "\n", "\n", "\n", - "Prior to the 1960s, graph theory primarily focused on the characteristics of individual graphs. In the 1960s, Paul Erdős and Alfred Rényi introduced a systematic approach to studying random graphs, which involves analyzing a collection, or ensemble, of many different graphs. Each graph in the ensemble is assigned a probability, and a property is said to hold with probability $P$ if the total probability of the graphs in the ensemble possessing that property is $P$, or if the fraction of graphs in the ensemble with the property is $P$. This method allows for the application of probability theory in conjunction with discrete math to study ensembles of graphs. A property is considered to hold for a class of graphs if the fraction of graphs in the ensemble without the property has zero measure, which is typically referred to as being true for \"almost every\" graph in the ensemble. The terms \"almost surely\" and \"with high probability\" may also be used, with the former generally indicating that the residual probability decreases exponentially with the size of the system\n", + "Prior to the 1960s, graph theory primarily focused on the characteristics of individual graphs. In the 1960s, Paul Erdős and Alfred Rényi introduced a systematic approach to studying random graphs, which involves analyzing a collection, or ensemble, of many different graphs. Each graph in the ensemble is assigned a probability, and a property is said to hold with probability $P$ if the total probability of the graphs in the ensemble possessing that property is $P$, or if the fraction of graphs in the ensemble with the property is $P$. This method allows for the application of probability theory in conjunction with discrete math to study ensembles of graphs. A property is considered to hold for a class of graphs if the fraction of graphs in the ensemble without the property has zero measure, which is typically referred to as being true for \"almost every\" graph in the ensemble. \n", + "\n", + "## Definition of a random graph\n", + "\n", + "Let $E_{n,N}$ denote the set of alla graphs having $n$ given labelled vertices $V_1,V_2, \\dots, V_n$ and $N$ edges. The graphs considered are supposed to be not oriented, without parallel edges and without slings. Thus a graph belonging to $E_{n,N}$ is obtained by choosing $N$ out of the $\\binom{n}{2}$ possible edges between the points $V_1,V_2, \\dots, V_n$, and therefore the number of elements of $E_{n,N}$ is given by the binomial coefficient $\\binom{\\binom{n}{2}}{N}$. \n", + "\n", + "A random graph $\\Gamma_{n,N}$ can be defined as a element of $E_{n,N}$ chosen at random, so that each of the elements of $E_{n,N}$ has the same probability of being chosen, namely $\\frac{1}{\\binom{\\binom{n}{2}}{N}}$.\n", + "\n", + "Let's try to modify this point of view and use a bit of probability theory. _We may consider the formation of a random graph as a stochastic process_ defined as follows: At time $t=1$ we choose out of the $\\binom{n}{2}$ possible edges between the points $V_1,V_2, \\dots, V_n$ $N$ edges, each of this edges having the same probability of being chosen; let this edge be denoted as $e_1$. At time $t=2$ we choose one of the possible $\\binom{n}{2} -1$, different from $e_1$, all this being equiprobable. Continuing this process at time $t=k+1$ we choose one of the possible $\\binom{n}{2} -k$, different from $e_1, e_2, \\dots, e_k$, all this being equiprobable, i.e having the probability $\\frac{1}{\\binom{n}{2} -k}$. We denote $\\Gamma_{n,N}$ the graph obtained by choosing $N$ edges in this way.\n", + "\n", + "> NOTE: the two definitions are equivalent, but the second one is more convenient for the study of the properties of random graphs. According to this interpretation we may study the evolution of random graphs, i.e. the step-by-step unraveling of the structure of the graph when $N$ increases. This will be an essential point in our study of the properties of small-worldness.\n", + "\n", + "\n", + "**SOURCES:** \n", "\n", + "- `[1]` On the evolution of random graphs, P. Erdős, A. Rényi, _Publ. Math. Inst. Hungar. Acad. Sci._, 5, 17-61 (1960).\n", "\n", "## Erdős-Rényi graphs\n", "\n", @@ -82,6 +96,9 @@ "\n", "Another property of interest is the average path length between any two nodes, which is typically of order $\\ln N$ in almost every graph of the ensemble (with $\\langle k \\rangle > 1$ and finite). This small, logarithmic distance is the source of the \"small-world\" phenomena that are characteristic of networks.\n", "\n", + "**SOURCE:**\n", + "- `[i]` Complex Networks: Structure, Robustness, and Function, R. Cohen, S. Havlin, D. ben-Avraham, H. E. Stanley, _Cambridge University Press, 2009_.\n", + "\n", "\n", "## Scale-free networks\n", "\n", @@ -141,6 +158,8 @@ "\n", "The degree distribution is not the only characteristic that can be used to describe a network. Other quantities, such as the degree-degree correlation (between connected nodes), spatial correlations, clustering coefficient, betweenness or centrality distribution, and self-similarity exponents, can also provide insight into the network's structure and behavior.\n", "\n", + "- `[i]` Complex Networks: Structure, Robustness, and Function, R. Cohen, S. Havlin, D. ben-Avraham, H. E. Stanley, _Cambridge University Press, 2009_.\n", + "\n", "# Diameter and fractal dimension\n", "\n", "" + "> **EXTRA:** If you want to see a visualization of a complete different graph, here you can check che collaboration network of the actors on the IMDb website. It has very distinct communities and clusters. Only actors with more then 100 movies have been considered. Click [here](https://lukefleed.xyz/graph/imdb-graph.html) to see the visualization." ] }, { @@ -883,18 +1010,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Introduzione da scrivere\n", + "# Properties of the networks\n", "\n", "To help us visualize the results of our analysis we can create a dataframe and fill it with all the information that we will retrive from our networks in this section.\n", "\n", - "As we'll see in the cells below, the full networks are very big, even after the filtering that we did. This leads to long run times for the functions that we are going to use. To avoid this, we are going to use a sub-sample of the networks. Depending on how much we want to sample, our results will be more or less accurate. \n", + "As we'll see in the cells below, the full networks are very big, even after the filtering that we did. This leads to long run times for the functions that we are going to use. To avoid this, we are going to use a sub-sample of the networks. Consider that depending on how much we want to sample, our results will be more or less accurate. \n", "\n", - "What I suggest to do while reviewing this network is to use higher values for the sampling rate, so that you can see the results faster. This will give you a general idea of how the implemented functions work. Then, at the end of this section I have provided a link from my GitHub repository where you can download the results obtained with very low sampling rates. In this way you can test the functions with mock-networks and see if they work as expected, then we can proceed with the analysis using the more accurate results that required more time to compute." + "What I suggest to do while reviewing this notebook is to use higher values for the sampling rate, so that you can see the results faster. This will give you a general idea of how the implemented functions work. Then, at the end of this section I have provided a link from my GitHub repository where you can download the results obtained with very low sampling rates. In this way you can test the functions with mock-networks and see if they work as expected, then we can proceed with the analysis using the more accurate results that required more time to compute." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -906,7 +1033,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -938,6 +1065,7 @@ " log N\n", " Average Shortest Path Length\n", " betweenness centrality\n", + " omega-coefficient\n", " \n", " \n", " \n", @@ -951,6 +1079,7 @@ " 8.778480\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 1\n", @@ -962,6 +1091,7 @@ " 8.030410\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 2\n", @@ -973,26 +1103,29 @@ " 7.751045\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 3\n", " Brightkite Friendship Graph\n", - " 5420\n", - " 14690\n", + " 1500\n", + " 1170\n", + " NaN\n", " NaN\n", + " 7.313220\n", " NaN\n", - " 8.597851\n", " NaN\n", " NaN\n", " \n", " \n", " 4\n", - " (Filtered) Gowalla Friendship Graph\n", - " 2294\n", - " 5548\n", + " Gowalla Friendship Graph\n", + " 1500\n", + " 2300\n", + " NaN\n", " NaN\n", + " 7.313220\n", " NaN\n", - " 7.738052\n", " NaN\n", " NaN\n", " \n", @@ -1006,38 +1139,39 @@ " 7.242082\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Graph Number of Nodes Number of Edges \\\n", - "0 Brightkite Checkins Graph 6493 292973 \n", - "1 Gowalla Checkins Graph 3073 62790 \n", - "2 Foursquare Checkins Graph 2324 246702 \n", - "3 Brightkite Friendship Graph 5420 14690 \n", - "4 (Filtered) Gowalla Friendship Graph 2294 5548 \n", - "5 Foursquare Friendship Graph 1397 5323 \n", + " Graph Number of Nodes Number of Edges Average Degree \\\n", + "0 Brightkite Checkins Graph 6493 292973 NaN \n", + "1 Gowalla Checkins Graph 3073 62790 NaN \n", + "2 Foursquare Checkins Graph 2324 246702 NaN \n", + "3 Brightkite Friendship Graph 1500 1170 NaN \n", + "4 Gowalla Friendship Graph 1500 2300 NaN \n", + "5 Foursquare Friendship Graph 1397 5323 NaN \n", "\n", - " Average Degree Average Clustering Coefficient log N \\\n", - "0 NaN NaN 8.778480 \n", - "1 NaN NaN 8.030410 \n", - "2 NaN NaN 7.751045 \n", - "3 NaN NaN 8.597851 \n", - "4 NaN NaN 7.738052 \n", - "5 NaN NaN 7.242082 \n", + " Average Clustering Coefficient log N Average Shortest Path Length \\\n", + "0 NaN 8.778480 NaN \n", + "1 NaN 8.030410 NaN \n", + "2 NaN 7.751045 NaN \n", + "3 NaN 7.313220 NaN \n", + "4 NaN 7.313220 NaN \n", + "5 NaN 7.242082 NaN \n", "\n", - " Average Shortest Path Length betweenness centrality \n", - "0 NaN NaN \n", - "1 NaN NaN \n", - "2 NaN NaN \n", - "3 NaN NaN \n", - "4 NaN NaN \n", - "5 NaN NaN " + " betweenness centrality omega-coefficient \n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 NaN NaN \n", + "5 NaN NaN " ] }, - "execution_count": 38, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1072,7 +1206,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1097,113 +1231,55 @@ " \n", " \n", " Graph\n", - " Number of Nodes\n", - " Number of Edges\n", " Average Degree\n", - " Average Clustering Coefficient\n", - " log N\n", - " Average Shortest Path Length\n", - " betweenness centrality\n", " \n", " \n", " \n", " \n", " 0\n", " Brightkite Checkins Graph\n", - " 6493\n", - " 292973\n", " 90.242723\n", - " NaN\n", - " 8.778480\n", - " NaN\n", - " NaN\n", " \n", " \n", " 1\n", " Gowalla Checkins Graph\n", - " 3073\n", - " 62790\n", " 40.865604\n", - " NaN\n", - " 8.030410\n", - " NaN\n", - " NaN\n", " \n", " \n", " 2\n", " Foursquare Checkins Graph\n", - " 2324\n", - " 246702\n", " 212.30809\n", - " NaN\n", - " 7.751045\n", - " NaN\n", - " NaN\n", " \n", " \n", " 3\n", " Brightkite Friendship Graph\n", - " 5420\n", - " 14690\n", - " 5.420664\n", - " NaN\n", - " 8.597851\n", - " NaN\n", - " NaN\n", + " 1.56\n", " \n", " \n", " 4\n", - " (Filtered) Gowalla Friendship Graph\n", - " 2294\n", - " 5548\n", - " 4.836966\n", - " NaN\n", - " 7.738052\n", - " NaN\n", - " NaN\n", + " Gowalla Friendship Graph\n", + " 3.066667\n", " \n", " \n", " 5\n", " Foursquare Friendship Graph\n", - " 1397\n", - " 5323\n", " 7.620616\n", - " NaN\n", - " 7.242082\n", - " NaN\n", - " NaN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Graph Number of Nodes Number of Edges \\\n", - "0 Brightkite Checkins Graph 6493 292973 \n", - "1 Gowalla Checkins Graph 3073 62790 \n", - "2 Foursquare Checkins Graph 2324 246702 \n", - "3 Brightkite Friendship Graph 5420 14690 \n", - "4 (Filtered) Gowalla Friendship Graph 2294 5548 \n", - "5 Foursquare Friendship Graph 1397 5323 \n", - "\n", - " Average Degree Average Clustering Coefficient log N \\\n", - "0 90.242723 NaN 8.778480 \n", - "1 40.865604 NaN 8.030410 \n", - "2 212.30809 NaN 7.751045 \n", - "3 5.420664 NaN 8.597851 \n", - "4 4.836966 NaN 7.738052 \n", - "5 7.620616 NaN 7.242082 \n", - "\n", - " Average Shortest Path Length betweenness centrality \n", - "0 NaN NaN \n", - "1 NaN NaN \n", - "2 NaN NaN \n", - "3 NaN NaN \n", - "4 NaN NaN \n", - "5 NaN NaN " + " Graph Average Degree\n", + "0 Brightkite Checkins Graph 90.242723\n", + "1 Gowalla Checkins Graph 40.865604\n", + "2 Foursquare Checkins Graph 212.30809\n", + "3 Brightkite Friendship Graph 1.56\n", + "4 Gowalla Friendship Graph 3.066667\n", + "5 Foursquare Friendship Graph 7.620616" ] }, - "execution_count": 39, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1213,7 +1289,7 @@ " avg_deg = np.mean([d for n, d in G.degree()])\n", " analysis_results.loc[analysis_results['Graph'] == G.name, 'Average Degree'] = avg_deg\n", "\n", - "analysis_results" + "analysis_results[['Graph', 'Average Degree']]" ] }, { @@ -1225,9 +1301,7 @@ "\n", "The clustering coefficient is usually related to a community represented by local structures. The usual definition of clustering is related to the number of triangles in the network. The clustering is high if two nodes sharing a neighbor have a high probability of being connected to each other. There are two common definitions of clustering. The first is global,\n", "\n", - "\\begin{equation}\n", - " C = \\frac{3 \\times \\text{the number of triangles in the network}}{\\text{the number of connected triples of vertices}}\n", - "\\end{equation}\n", + "$$ C = \\frac{3 \\times \\text{the number of triangles in the network}}{\\text{the number of connected triples of vertices}}$$\n", "\n", "where a “connected triple” means a single vertex with edges running to an unordered\n", "pair of other vertices. \n", @@ -1246,11 +1320,13 @@ "\n", "In both cases the clustering is in the range $0 \\leq C \\leq 1$. \n", "\n", - "In random graph models such as the ER model and the configuration model, the clustering coefficient is low and decreases to $0$ as the system size increases. This is also the situation in many growing network models. However, in many real-world networks the clustering coefficient is rather high and remains constant for large network sizes. This observation led to the introduction of the small-world model, which offers a combination of a regular lattice with high clustering and a random graph. \n", + "In random graph models such as the ER model and the configuration model, the clustering coefficient is low and decreases to $0$ as the system size increases. This is also the situation in many growing network models. However, in many real-world networks the clustering coefficient is rather high and remains constant for large network sizes. \n", + "\n", + "> This observation led to the introduction of the small-world model, which offers a combination of a regular lattice with high clustering and a random graph. \n", "\n", "---\n", "\n", - "As one can imagine by the definition given above, this operation is very expensive. The library `networkx` provides a function to compute the clustering coefficient of a graph. In particular, the function `average_clustering` computes the average clustering coefficient of a graph. \n", + "The library `networkx` provides a function to compute the clustering coefficient of a graph. In particular, the function `average_clustering` computes the average clustering coefficient of a graph. \n", "\n", " 8\u001b[0m \u001b[39mfor\u001b[39;00m graph \u001b[39min\u001b[39;00m graphs_all:\n\u001b[1;32m 9\u001b[0m G \u001b[39m=\u001b[39m create_random_graphs(graph, model\u001b[39m=\u001b[39mmodel_name, save \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m 10\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mRandom graph created for \u001b[39m\u001b[39m\"\u001b[39m, graph\u001b[39m.\u001b[39mname, \u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39mStarting computation of betweenness centrality...\u001b[39m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'graphs_all' is not defined" ] } ], @@ -16622,14 +16881,13 @@ "# As said before, for a quick testing I suggest to use k=0.6 and at least k=0.4 for accurate results\n", "\n", "# uncomment the model that you want to use for the random graphs\n", - "\n", "# model_name = 'watts_strogatz'\n", "model_name = 'erdos_renyi'\n", "\n", "random_graphs = {}\n", "for graph in graphs_all:\n", " G = create_random_graphs(graph, model=model_name, save = False)\n", - " print(\"Random graph created for \", graph.name, \"Starting computation of betweenness centrality...\")\n", + " print(\"Random graph created for \", graph.name, \"\\nStarting computation of betweenness centrality...\")\n", " betweenness_centrality = np.mean(list(betweenness_centrality_parallel(G, 6, k = 0.4).values()))\n", " print(\"\\tBetweenness centrality for Erdos-Renyi random graph: \", betweenness_centrality)\n", " random_graphs[graph.name] = betweenness_centrality\n", @@ -16638,37 +16896,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Brightkite Checkins Graph': 0.0003728834232472551,\n", - " 'Gowalla Checkins Graph': 0.0009215261155179815,\n", - " 'Foursquare Checkins Graph': 0.0006522226121634739,\n", - " 'Brightkite Friendship Graph': 0.0016407812858385549,\n", - " 'Gowalla Friendship Graph': 0.0037251547240147328,\n", - " 'Foursquare Friendship Graph': 0.0042446600624415146}" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "random_graphs" - ] - }, - { - "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -16744,41 +16977,23 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 24, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Brightkite Checkins Graph': 0.6426519071903248,\n", - " 'Gowalla Checkins Graph': 0.6159366386543966,\n", - " 'Foursquare Checkins Graph': 0.6949399573838294,\n", - " 'Brightkite Friendship Graph': 0.4044470961191924,\n", - " 'Gowalla Friendship Graph': 0.4228365321024048,\n", - " 'Foursquare Friendship Graph': 0.4585372995852263}" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "generalized_cc = {}\n", "for graph in graphs_all:\n", - " generalized_cc[graph.name] = generalized_average_clustering_coefficient(graph)\n", - "\n", - "generalized_cc" + " generalized_cc[graph.name] = generalized_average_clustering_coefficient(graph)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -16788,10 +17003,6 @@ } ], "source": [ - "# now we can compare the results of the generalized average clustering coefficient with the original average clustering coefficient. Use matplotlib to plot the results as an histogram with two bars for each graph\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", "fig, ax = plt.subplots(figsize=(15, 10))\n", "index = np.arange(len(generalized_cc))\n", "bar_width = 0.35\n", @@ -16800,12 +17011,12 @@ "rects1 = plt.bar(index, analysis_results['Average Clustering Coefficient'], bar_width,\n", "alpha=opacity,\n", "color='b',\n", - "label='Original Graph')\n", + "label='Standard Clustering')\n", "\n", "rects2 = plt.bar(index + bar_width, generalized_cc.values(), bar_width,\n", "alpha=opacity,\n", "color='g',\n", - "label='Generalized Graph')\n", + "label='Generalized Clustering')\n", "\n", "plt.xlabel('Graph')\n", "plt.ylabel('Average Clustering Coefficient')\n", @@ -16832,14 +17043,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Omega coefficient\n", + "## Conclusion: Omega coefficient\n", "\n", "We have already discussed a lot in the previous sections about this measure, let's see the results that we obtained after days of computations on the server:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -16871,48 +17082,48 @@ " \n", " 0\n", " Brightkite Checkins Graph\n", - " -0.180\n", + " NaN\n", " \n", " \n", " 1\n", " Gowalla Checkins Graph\n", - " -0.240\n", + " NaN\n", " \n", " \n", " 2\n", " Foursquare Checkins Graph\n", - " -0.056\n", + " NaN\n", " \n", " \n", " 3\n", " Brightkite Friendship Graph\n", - " -0.200\n", + " NaN\n", " \n", " \n", " 4\n", " Gowalla Friendship Graph\n", - " -0.250\n", + " NaN\n", " \n", " \n", " 5\n", " Foursquare Friendship Graph\n", - " -0.170\n", + " NaN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Graph omega-coefficient\n", - "0 Brightkite Checkins Graph -0.180\n", - "1 Gowalla Checkins Graph -0.240\n", - "2 Foursquare Checkins Graph -0.056\n", - "3 Brightkite Friendship Graph -0.200\n", - "4 Gowalla Friendship Graph -0.250\n", - "5 Foursquare Friendship Graph -0.170" + " Graph omega-coefficient\n", + "0 Brightkite Checkins Graph NaN\n", + "1 Gowalla Checkins Graph NaN\n", + "2 Foursquare Checkins Graph NaN\n", + "3 Brightkite Friendship Graph NaN\n", + "4 Gowalla Friendship Graph NaN\n", + "5 Foursquare Friendship Graph NaN" ] }, - "execution_count": 11, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -16926,17 +17137,42 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This results are a bit of a surprise. The small-world coefficient (omega) measures how much a network is like a lattice or a random graph. Negative values mean G is similar to a lattice whereas positive values mean G is a random graph. Values close to 0 mean that G has small-world characteristics.\n", + "To give you a better idea of how time consuming is this computation, I will report below the time that it took to compute the omega coefficient for the networks generated from all this networks:\n", + "\n", + "\n", + "\n", + "| Network | Time |\n", + "|:-------:|:----:|\n", + "| Brightkite Checkins | 9d 11h 25m |\n", + "| Gowalla Checkins | 3d 2h 55m |\n", + "| FourSquare Checkins | 6d 14h 13m |\n", + "| Brightkite Friendships | 17h 55m |\n", + "| Gowalla Friendships | 2h 22m |\n", + "| FourSquare Friendships | 2h 9m |\n", + "\n", + "Note that due to the small size of the friendships graphs, I have been able to compute the omega coefficent for the whole networks. However, for the checkins graphs, I had to take a 50% sample of the nodes. In both cases, I used `niter` and `nrand` equal to 3." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "This results are a bit of a surprise. The small-world coefficient (omega) measures how much a network is like a lattice or a random graph. Negative values mean the graph is similar to a lattice whereas positive values mean the graph is more random-like. Values close to 0 instead, should represent small-world characteristics.\n", "\n", - "Based only on this metric, we may conclude that all the networks are small-worlds. In fact, all the values of the omega coefficient are $~0.2$ (with the exception of the foursquare checkins graph, whose value is very close to $0$). However, I don't this this is the case. \n", + "Based only on this metric, we may conclude that all the networks are small-worlds. In fact, all the values of the omega coefficient are ~$0.2$ (with the exception of the foursquare checkins graph, whose value is very close to $0$). However, I don't think this is the case. \n", "\n", - "# Conclusion\n", + "We have seen in the previous section that the $\\omega$ coefficient can be tricked by networks that have a very low clustering coefficient, and in my opinion this is exactly what is happening here. The networks generated from the friendships have a very low clustering coefficient, and therefore they are biasing the $\\omega$ coefficient. This conclusion is supported by the fact the measures like the betweenness centrality and the clustering coefficient that we have shown before, suggest that the networks generated from the friendships are not small-world networks. \n", "\n", - "We have seen in the previous section that the $\\omega$ coefficient can be tricked by networks that have a very low clustering coefficient, and in my opinion this is excatly what is happening here. The networks generated from the friendships have a very low clustering coefficient, and therefore they are biasing the $\\omega$ coefficient. This conclusion is supported by the fact the measures like the betweenness centrality and the clustering coefficient that we have shown before, suggest that the networks generated from the friendships are not small-world networks. \n", + "Furthermore, on a more heuristic level, those graphs represent a social network with data taken in 2010, a time when social networks were not as popular as they are today. Therefore, I would not be surprised if those networks are not small-worlds. \n", "\n", - "Furthermore, on a more euristic level, those graphs represent a social network with data taken in 2010, a time when social networks were not as popular as they are today. Therefore, I would not be surprised if those networks were not small-world networks. \n", + "On the other hand, on a more technical level, I think that using `niter` and `nrand` equal to $3$ is not enough to reach a definitive conclusion. However, choosing bigger values would have exponentially increased the time needed to compute the $\\omega$ coefficient and reducing the number of nodes in the sample would have reduced the accuracy of the results. \n", + "\n", + "---\n", "\n", - "This study evidences why the charaterization of the small-world propriety of a real-world network is still subject of debate. Even if we have used the most reliable techniques that the literature has to offer, we still have not been able to reach a definitive conclusion." + "To summarize the work done: this study evidences why the characterization of the small-world propriety of a real-world network is still subject of debate. Even if we have used the most reliable techniques that the literature has to offer, we still have not been able to reach a definitive conclusion and specific observations on the single networks were necessary. For real networks, we still have not reached the completeness (in a metaphorical way, not topological) of the theoretical models firstly proposed in the 60s by Erdős and Rényi." ] } ], diff --git a/omega_sampled_server.py b/omega_sampled_server.py index e524afb..454a29e 100755 --- a/omega_sampled_server.py +++ b/omega_sampled_server.py @@ -31,20 +31,11 @@ if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("graph", help="Name of the graph to be used. Options are 'checkins-foursquare', 'checkins-gowalla', 'checkins-brightkite', 'friends-foursquare', 'friends-gowalla', 'friends-brightkite'") parser.add_argument("k", help="Percentage of nodes to be sampled. Needs to be a float between 0 and 1") - parser.add_argument("niter", help="Number of rewiring per edge. Needs to be an integer. Default is 5") - parser.add_argument("nrand", help="Number of random graphs. Needs to be an integer. Default is 5") + parser.add_argument("--niter", help="Number of rewiring per edge. Needs to be an integer. Default is 5", default=5) + parser.add_argument("--nrand", help="Number of random graphs. Needs to be an integer. Default is 5", default=5) parser.add_help = True args = parser.parse_args() - # if no input is given for niter and nrand, set them to default values - if args.niter == None: - print("No input for niter. Setting it to default value: 5") - args.niter = 5 - - if args.nrand == None: - print("No input for nrand. Setting it to default value: 5") - args.nrand = 5 - # the name of the graph is the first part of the input string name = args.graph.split('-')[1] if 'checkins' in args.graph: diff --git a/testing.ipynb b/testing.ipynb index 07edd25..888c4c0 100644 --- a/testing.ipynb +++ b/testing.ipynb @@ -16,809 +16,171 @@ "import pandas as pd\n", "import networkx as nx\n", "import plotly.graph_objects as go\n", - "# from utils import *\n", + "from utils import *\n", "from collections import Counter\n", "from tqdm import tqdm\n", "import time\n", "import geopandas as gpd\n", "import gdown # for downloading files from google drive\n", "import shutil\n", - "# ignore warnings\n", "import warnings\n", "import sys\n", + "from pyvis.network import Network\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GraphNumber of NodesNumber of EdgesAverage DegreeAverage Clustering Coefficientlog NAverage Shortest Path Lengthbetweenness centrality
0Brightkite Checkins Graph649329297390.2427230.7139998.7784803.0133690.000534
1Gowalla Checkins Graph30736279040.8656040.5483728.0304103.5080310.001277
2Foursquare Checkins Graph2324246702212.308090.652737.7510452.1861120.000938
3Brightkite Friendship Graph5420146905.4206640.2185718.5978515.2318070.000664
4(Filtered) Gowalla Friendship Graph229455484.8369660.2342937.7380525.3964880.001331
5Foursquare Friendship Graph139753237.6206160.1834857.2420826.458410.001531
\n", - "
" - ], - "text/plain": [ - " Graph Number of Nodes Number of Edges \\\n", - "0 Brightkite Checkins Graph 6493 292973 \n", - "1 Gowalla Checkins Graph 3073 62790 \n", - "2 Foursquare Checkins Graph 2324 246702 \n", - "3 Brightkite Friendship Graph 5420 14690 \n", - "4 (Filtered) Gowalla Friendship Graph 2294 5548 \n", - "5 Foursquare Friendship Graph 1397 5323 \n", - "\n", - " Average Degree Average Clustering Coefficient log N \\\n", - "0 90.242723 0.713999 8.778480 \n", - "1 40.865604 0.548372 8.030410 \n", - "2 212.30809 0.65273 7.751045 \n", - "3 5.420664 0.218571 8.597851 \n", - "4 4.836966 0.234293 7.738052 \n", - "5 7.620616 0.183485 7.242082 \n", - "\n", - " Average Shortest Path Length betweenness centrality \n", - "0 3.013369 0.000534 \n", - "1 3.508031 0.001277 \n", - "2 2.186112 0.000938 \n", - "3 5.231807 0.000664 \n", - "4 5.396488 0.001331 \n", - "5 6.45841 0.001531 " - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "analysis_results = pd.read_pickle('analysis_results.pkl')\n", - "analysis_results" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GraphNumber of NodesNumber of EdgesAverage DegreeAverage Clustering Coefficientlog NAverage Shortest Path Lengthbetweenness centralityomega-coefficient
0Brightkite Checkins Graph649329297390.2427230.7139998.7784803.0133690.000534NaN
1Gowalla Checkins Graph30736279040.8656040.5483728.0304103.5080310.001277NaN
2Foursquare Checkins Graph2324246702212.308090.652737.7510452.1861120.000938NaN
3Brightkite Friendship Graph5420146905.4206640.2185718.5978515.2318070.000664NaN
4(Filtered) Gowalla Friendship Graph229455484.8369660.2342937.7380525.3964880.001331NaN
5Foursquare Friendship Graph139753237.6206160.1834857.2420826.458410.001531NaN
\n", - "
" - ], - "text/plain": [ - " Graph Number of Nodes Number of Edges \\\n", - "0 Brightkite Checkins Graph 6493 292973 \n", - "1 Gowalla Checkins Graph 3073 62790 \n", - "2 Foursquare Checkins Graph 2324 246702 \n", - "3 Brightkite Friendship Graph 5420 14690 \n", - "4 (Filtered) Gowalla Friendship Graph 2294 5548 \n", - "5 Foursquare Friendship Graph 1397 5323 \n", - "\n", - " Average Degree Average Clustering Coefficient log N \\\n", - "0 90.242723 0.713999 8.778480 \n", - "1 40.865604 0.548372 8.030410 \n", - "2 212.30809 0.65273 7.751045 \n", - "3 5.420664 0.218571 8.597851 \n", - "4 4.836966 0.234293 7.738052 \n", - "5 7.620616 0.183485 7.242082 \n", - "\n", - " Average Shortest Path Length betweenness centrality omega-coefficient \n", - "0 3.013369 0.000534 NaN \n", - "1 3.508031 0.001277 NaN \n", - "2 2.186112 0.000938 NaN \n", - "3 5.231807 0.000664 NaN \n", - "4 5.396488 0.001331 NaN \n", - "5 6.45841 0.001531 NaN " - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "analysis_results['omega-coefficient'] = np.nan\n", - "analysis_results" + "import multiprocessing\n", + "import random\n", + "import networkx as nx\n", + "import numpy as np\n", + "import math\n", + "\n", + "def parallel_omega(G, nrand=10, seed=None):\n", + "\n", + " random.seed(seed)\n", + " if not nx.is_connected(G):\n", + " G = G.subgraph(max(nx.connected_components(G), key=len))\n", + "\n", + " if len(G) == 1:\n", + " return 0\n", + "\n", + " niter_lattice_reference = nrand\n", + " niter_random_reference = nrand * 2\n", + " \n", + " def worker(queue):\n", + " while True:\n", + " task = queue.get()\n", + " if task is None:\n", + " break\n", + " random_graph = nx.random_reference(G)\n", + " lattice_graph = nx.lattice_reference(G)\n", + " random_shortest_path = nx.average_shortest_path_length(random_graph)\n", + " lattice_clustering = nx.average_clustering(lattice_graph)\n", + " queue.put((random_shortest_path, lattice_clustering))\n", + " \n", + " n_processes = multiprocessing.cpu_count()\n", + " manager = multiprocessing.Manager()\n", + " queue = manager.Queue()\n", + " processes = [multiprocessing.Process(target=worker, args=(queue,)) for _ in range(n_processes)]\n", + " for process in processes:\n", + " process.start()\n", + " \n", + " for _ in range(nrand):\n", + " queue.put(1)\n", + " \n", + " for _ in range(n_processes):\n", + " queue.put(None)\n", + " \n", + " for process in processes:\n", + " process.join()\n", + " \n", + " shortest_paths = []\n", + " clustering_coeffs = []\n", + " while not queue.empty():\n", + " random_shortest_path, lattice_clustering = queue.get()\n", + " shortest_paths.append(random_shortest_path)\n", + " clustering_coeffs.append(lattice_clustering)\n", + " \n", + " L = nx.average_shortest_path_length(G)\n", + " C = nx.average_clustering(G)\n", + "\n", + " # kill the process\n", + " for process in processes:\n", + " process.terminate()\n", + " process.join()\n", + "\n", + " omega = (np.mean(shortest_paths) / L) - (C / np.mean(clustering_coeffs))\n", + "\n", + "\n", + " return omega" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GraphNumber of NodesNumber of EdgesAverage DegreeAverage Clustering Coefficientlog NAverage Shortest Path Lengthbetweenness centralityomega-coefficient
0Brightkite Checkins Graph649329297390.2427230.7139998.7784803.0133690.000534NaN
1Gowalla Checkins Graph30736279040.8656040.5483728.0304103.5080310.001277NaN
2Foursquare Checkins Graph2324246702212.308090.652737.7510452.1861120.000938NaN
3Brightkite Friendship Graph5420146905.4206640.2185718.5978515.2318070.000664NaN
4(Filtered) Gowalla Friendship Graph229455484.8369660.2342937.7380525.3964880.001331NaN
5Foursquare Friendship Graph139753237.6206160.1834857.2420826.458410.001531NaN
\n", - "
" - ], "text/plain": [ - " Graph Number of Nodes Number of Edges \\\n", - "0 Brightkite Checkins Graph 6493 292973 \n", - "1 Gowalla Checkins Graph 3073 62790 \n", - "2 Foursquare Checkins Graph 2324 246702 \n", - "3 Brightkite Friendship Graph 5420 14690 \n", - "4 (Filtered) Gowalla Friendship Graph 2294 5548 \n", - "5 Foursquare Friendship Graph 1397 5323 \n", - "\n", - " Average Degree Average Clustering Coefficient log N \\\n", - "0 90.242723 0.713999 8.778480 \n", - "1 40.865604 0.548372 8.030410 \n", - "2 212.30809 0.65273 7.751045 \n", - "3 5.420664 0.218571 8.597851 \n", - "4 4.836966 0.234293 7.738052 \n", - "5 7.620616 0.183485 7.242082 \n", - "\n", - " Average Shortest Path Length betweenness centrality omega-coefficient \n", - "0 3.013369 0.000534 NaN \n", - "1 3.508031 0.001277 NaN \n", - "2 2.186112 0.000938 NaN \n", - "3 5.231807 0.000664 NaN \n", - "4 5.396488 0.001331 NaN \n", - "5 6.45841 0.001531 NaN " + "'Graph with 200 nodes and 584 edges'" ] }, - "execution_count": 16, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# rename (Filtered) Gowalla Friendship Graph in Gowalla Friendship Graph\n", - "analysis_results.loc[analysis_results['Graph'] == 'Filtered Gowalla Friendship Graph', 'Graph'] = 'Gowalla Friendship Graph'\n", - "analysis_results" + "G = nx.erdos_renyi_graph(200, 0.03)\n", + "G = G.subgraph(max(nx.connected_components(G), key=len))\n", + "nx.info(G)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GraphNumber of NodesNumber of EdgesAverage DegreeAverage Clustering Coefficientlog NAverage Shortest Path Lengthbetweenness centralityomega-coefficient
0Brightkite Checkins Graph649329297390.2427230.7139998.7784803.0133690.000534-0.180
1Gowalla Checkins Graph30736279040.8656040.5483728.0304103.5080310.001277-0.240
2Foursquare Checkins Graph2324246702212.308090.652737.7510452.1861120.000938-0.056
3Brightkite Friendship Graph5420146905.4206640.2185718.5978515.2318070.000664NaN
4(Filtered) Gowalla Friendship Graph229455484.8369660.2342937.7380525.3964880.001331NaN
5Foursquare Friendship Graph139753237.6206160.1834857.2420826.458410.001531NaN
\n", - "
" - ], "text/plain": [ - " Graph Number of Nodes Number of Edges \\\n", - "0 Brightkite Checkins Graph 6493 292973 \n", - "1 Gowalla Checkins Graph 3073 62790 \n", - "2 Foursquare Checkins Graph 2324 246702 \n", - "3 Brightkite Friendship Graph 5420 14690 \n", - "4 (Filtered) Gowalla Friendship Graph 2294 5548 \n", - "5 Foursquare Friendship Graph 1397 5323 \n", - "\n", - " Average Degree Average Clustering Coefficient log N \\\n", - "0 90.242723 0.713999 8.778480 \n", - "1 40.865604 0.548372 8.030410 \n", - "2 212.30809 0.65273 7.751045 \n", - "3 5.420664 0.218571 8.597851 \n", - "4 4.836966 0.234293 7.738052 \n", - "5 7.620616 0.183485 7.242082 \n", - "\n", - " Average Shortest Path Length betweenness centrality omega-coefficient \n", - "0 3.013369 0.000534 -0.180 \n", - "1 3.508031 0.001277 -0.240 \n", - "2 2.186112 0.000938 -0.056 \n", - "3 5.231807 0.000664 NaN \n", - "4 5.396488 0.001331 NaN \n", - "5 6.45841 0.001531 NaN " + "0.6776975801779451" ] }, - "execution_count": 18, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Foursquare Checkins Graph : -0.056\n", - "# Gowalla Checkins Graph : -0.24\n", - "# Brightkite Checkins Graph : -0.18\n", - "\n", - "# add omega-coefficient to the respective graphs\n", - "analysis_results.loc[analysis_results['Graph'] == 'Foursquare Checkins Graph', 'omega-coefficient'] = -0.056\n", - "analysis_results.loc[analysis_results['Graph'] == 'Gowalla Checkins Graph', 'omega-coefficient'] = -0.24\n", - "analysis_results.loc[analysis_results['Graph'] == 'Brightkite Checkins Graph', 'omega-coefficient'] = -0.18\n", - "analysis_results" + "omega = parallel_omega(G, nrand=10, seed=42)\n", + "omega" ] }, { "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# rename (Filtered) Gowalla Friendship Graph in Gowalla Friendship Graph\n", - "analysis_results.loc[analysis_results['Graph'] == '(Filtered) Gowalla Friendship Graph', 'Graph'] = 'Gowalla Friendship Graph'" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "# FourSquare Friendship Graph : -0.17\n", - "# Gowalla Friendship Graph : -0.25\n", - "# Brightkite Friendship Graph : -0.20\n", - "\n", - "# add omega-coefficient to the respective graphs\n", - "analysis_results.loc[analysis_results['Graph'] == 'Foursquare Friendship Graph', 'omega-coefficient'] = -0.17\n", - "analysis_results.loc[analysis_results['Graph'] == 'Gowalla Friendship Graph', 'omega-coefficient'] = -0.25\n", - "analysis_results.loc[analysis_results['Graph'] == 'Brightkite Friendship Graph', 'omega-coefficient'] = -0.20" - ] - }, - { - "cell_type": "code", - "execution_count": 27, + "execution_count": 4, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GraphNumber of NodesNumber of EdgesAverage DegreeAverage Clustering Coefficientlog NAverage Shortest Path Lengthbetweenness centralityomega-coefficient
0Brightkite Checkins Graph649329297390.2427230.7139998.7784803.0133690.000534-0.180
1Gowalla Checkins Graph30736279040.8656040.5483728.0304103.5080310.001277-0.240
2Foursquare Checkins Graph2324246702212.308090.652737.7510452.1861120.000938-0.056
3Brightkite Friendship Graph5420146905.4206640.2185718.5978515.2318070.000664-0.200
4Gowalla Friendship Graph229455484.8369660.2342937.7380525.3964880.001331-0.250
5Foursquare Friendship Graph139753237.6206160.1834857.2420826.458410.001531-0.170
\n", - "
" - ], - "text/plain": [ - " Graph Number of Nodes Number of Edges Average Degree \\\n", - "0 Brightkite Checkins Graph 6493 292973 90.242723 \n", - "1 Gowalla Checkins Graph 3073 62790 40.865604 \n", - "2 Foursquare Checkins Graph 2324 246702 212.30809 \n", - "3 Brightkite Friendship Graph 5420 14690 5.420664 \n", - "4 Gowalla Friendship Graph 2294 5548 4.836966 \n", - "5 Foursquare Friendship Graph 1397 5323 7.620616 \n", - "\n", - " Average Clustering Coefficient log N Average Shortest Path Length \\\n", - "0 0.713999 8.778480 3.013369 \n", - "1 0.548372 8.030410 3.508031 \n", - "2 0.65273 7.751045 2.186112 \n", - "3 0.218571 8.597851 5.231807 \n", - "4 0.234293 7.738052 5.396488 \n", - "5 0.183485 7.242082 6.45841 \n", - "\n", - " betweenness centrality omega-coefficient \n", - "0 0.000534 -0.180 \n", - "1 0.001277 -0.240 \n", - "2 0.000938 -0.056 \n", - "3 0.000664 -0.200 \n", - "4 0.001331 -0.250 \n", - "5 0.001531 -0.170 " - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m standard_omega \u001b[39m=\u001b[39m nx\u001b[39m.\u001b[39;49momega(G, nrand\u001b[39m=\u001b[39;49m\u001b[39m10\u001b[39;49m, seed\u001b[39m=\u001b[39;49m\u001b[39m42\u001b[39;49m)\n\u001b[1;32m 2\u001b[0m standard_omega\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/utils/decorators.py:845\u001b[0m, in \u001b[0;36margmap.__call__..func\u001b[0;34m(_argmap__wrapper, *args, **kwargs)\u001b[0m\n\u001b[1;32m 844\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfunc\u001b[39m(\u001b[39m*\u001b[39margs, __wrapper\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m--> 845\u001b[0m \u001b[39mreturn\u001b[39;00m argmap\u001b[39m.\u001b[39;49m_lazy_compile(__wrapper)(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m compilation 14:6\u001b[0m, in \u001b[0;36margmap_omega_9\u001b[0;34m(G, niter, nrand, seed)\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39minspect\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mitertools\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mre\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcollections\u001b[39;00m \u001b[39mimport\u001b[39;00m defaultdict\n\u001b[1;32m 8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcontextlib\u001b[39;00m \u001b[39mimport\u001b[39;00m contextmanager\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/smallworld.py:367\u001b[0m, in \u001b[0;36momega\u001b[0;34m(G, niter, nrand, seed)\u001b[0m\n\u001b[1;32m 363\u001b[0m niter_random_reference \u001b[39m=\u001b[39m niter \u001b[39m*\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m 365\u001b[0m \u001b[39mfor\u001b[39;00m _ \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(nrand):\n\u001b[1;32m 366\u001b[0m \u001b[39m# Generate random graph\u001b[39;00m\n\u001b[0;32m--> 367\u001b[0m Gr \u001b[39m=\u001b[39m random_reference(G, niter\u001b[39m=\u001b[39;49mniter_random_reference, seed\u001b[39m=\u001b[39;49mseed)\n\u001b[1;32m 368\u001b[0m randMetrics[\u001b[39m\"\u001b[39m\u001b[39mL\u001b[39m\u001b[39m\"\u001b[39m]\u001b[39m.\u001b[39mappend(nx\u001b[39m.\u001b[39maverage_shortest_path_length(Gr))\n\u001b[1;32m 370\u001b[0m \u001b[39m# Generate lattice graph\u001b[39;00m\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/utils/decorators.py:845\u001b[0m, in \u001b[0;36margmap.__call__..func\u001b[0;34m(_argmap__wrapper, *args, **kwargs)\u001b[0m\n\u001b[1;32m 844\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfunc\u001b[39m(\u001b[39m*\u001b[39margs, __wrapper\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m--> 845\u001b[0m \u001b[39mreturn\u001b[39;00m argmap\u001b[39m.\u001b[39;49m_lazy_compile(__wrapper)(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m compilation 24:6\u001b[0m, in \u001b[0;36margmap_random_reference_19\u001b[0;34m(G, niter, connectivity, seed)\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39minspect\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mitertools\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mre\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcollections\u001b[39;00m \u001b[39mimport\u001b[39;00m defaultdict\n\u001b[1;32m 8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcontextlib\u001b[39;00m \u001b[39mimport\u001b[39;00m contextmanager\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/smallworld.py:100\u001b[0m, in \u001b[0;36mrandom_reference\u001b[0;34m(G, niter, connectivity, seed)\u001b[0m\n\u001b[1;32m 97\u001b[0m G\u001b[39m.\u001b[39mremove_edge(c, d)\n\u001b[1;32m 99\u001b[0m \u001b[39m# Check if the graph is still connected\u001b[39;00m\n\u001b[0;32m--> 100\u001b[0m \u001b[39mif\u001b[39;00m connectivity \u001b[39mand\u001b[39;00m local_conn(G, a, b) \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[1;32m 101\u001b[0m \u001b[39m# Not connected, revert the swap\u001b[39;00m\n\u001b[1;32m 102\u001b[0m G\u001b[39m.\u001b[39mremove_edge(a, d)\n\u001b[1;32m 103\u001b[0m G\u001b[39m.\u001b[39mremove_edge(c, b)\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/connectivity/connectivity.py:649\u001b[0m, in \u001b[0;36mlocal_edge_connectivity\u001b[0;34m(G, s, t, flow_func, auxiliary, residual, cutoff)\u001b[0m\n\u001b[1;32m 646\u001b[0m \u001b[39melif\u001b[39;00m flow_func \u001b[39mis\u001b[39;00m boykov_kolmogorov:\n\u001b[1;32m 647\u001b[0m kwargs[\u001b[39m\"\u001b[39m\u001b[39mcutoff\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m cutoff\n\u001b[0;32m--> 649\u001b[0m \u001b[39mreturn\u001b[39;00m nx\u001b[39m.\u001b[39;49mmaximum_flow_value(H, s, t, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/flow/maxflow.py:307\u001b[0m, in \u001b[0;36mmaximum_flow_value\u001b[0;34m(flowG, _s, _t, capacity, flow_func, **kwargs)\u001b[0m\n\u001b[1;32m 304\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m callable(flow_func):\n\u001b[1;32m 305\u001b[0m \u001b[39mraise\u001b[39;00m nx\u001b[39m.\u001b[39mNetworkXError(\u001b[39m\"\u001b[39m\u001b[39mflow_func has to be callable.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 307\u001b[0m R \u001b[39m=\u001b[39m flow_func(flowG, _s, _t, capacity\u001b[39m=\u001b[39;49mcapacity, value_only\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 309\u001b[0m \u001b[39mreturn\u001b[39;00m R\u001b[39m.\u001b[39mgraph[\u001b[39m\"\u001b[39m\u001b[39mflow_value\u001b[39m\u001b[39m\"\u001b[39m]\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/flow/edmondskarp.py:237\u001b[0m, in \u001b[0;36medmonds_karp\u001b[0;34m(G, s, t, capacity, residual, value_only, cutoff)\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39medmonds_karp\u001b[39m(\n\u001b[1;32m 121\u001b[0m G, s, t, capacity\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mcapacity\u001b[39m\u001b[39m\"\u001b[39m, residual\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, value_only\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, cutoff\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m\n\u001b[1;32m 122\u001b[0m ):\n\u001b[1;32m 123\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"Find a maximum single-commodity flow using the Edmonds-Karp algorithm.\u001b[39;00m\n\u001b[1;32m 124\u001b[0m \n\u001b[1;32m 125\u001b[0m \u001b[39m This function returns the residual network resulting after computing\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 235\u001b[0m \n\u001b[1;32m 236\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 237\u001b[0m R \u001b[39m=\u001b[39m edmonds_karp_impl(G, s, t, capacity, residual, cutoff)\n\u001b[1;32m 238\u001b[0m R\u001b[39m.\u001b[39mgraph[\u001b[39m\"\u001b[39m\u001b[39malgorithm\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39medmonds_karp\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 239\u001b[0m \u001b[39mreturn\u001b[39;00m R\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/flow/edmondskarp.py:104\u001b[0m, in \u001b[0;36medmonds_karp_impl\u001b[0;34m(G, s, t, capacity, residual, cutoff)\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[39mraise\u001b[39;00m nx\u001b[39m.\u001b[39mNetworkXError(\u001b[39m\"\u001b[39m\u001b[39msource and sink are the same node\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 103\u001b[0m \u001b[39mif\u001b[39;00m residual \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 104\u001b[0m R \u001b[39m=\u001b[39m build_residual_network(G, capacity)\n\u001b[1;32m 105\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 106\u001b[0m R \u001b[39m=\u001b[39m residual\n", + "File \u001b[0;32m/usr/lib/python3.10/site-packages/networkx/algorithms/flow/utils.py:139\u001b[0m, in \u001b[0;36mbuild_residual_network\u001b[0;34m(G, capacity)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m R\u001b[39m.\u001b[39mhas_edge(u, v):\n\u001b[1;32m 136\u001b[0m \u001b[39m# Both (u, v) and (v, u) must be present in the residual\u001b[39;00m\n\u001b[1;32m 137\u001b[0m \u001b[39m# network.\u001b[39;00m\n\u001b[1;32m 138\u001b[0m R\u001b[39m.\u001b[39madd_edge(u, v, capacity\u001b[39m=\u001b[39mr)\n\u001b[0;32m--> 139\u001b[0m R\u001b[39m.\u001b[39;49madd_edge(v, u, capacity\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m)\n\u001b[1;32m 140\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 141\u001b[0m \u001b[39m# The edge (u, v) was added when (v, u) was visited.\u001b[39;00m\n\u001b[1;32m 142\u001b[0m R[u][v][\u001b[39m\"\u001b[39m\u001b[39mcapacity\u001b[39m\u001b[39m\"\u001b[39m] \u001b[39m=\u001b[39m r\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] } ], "source": [ - "analysis_results\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# save the results into a pickle file\n", - "analysis_results.to_pickle('analysis_results.pkl')" + "standard_omega = nx.omega(G, nrand=10, seed=42)\n", + "standard_omega" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.8 64-bit", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -832,7 +194,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9 (main, Dec 19 2022, 17:35:49) [GCC 12.2.0]" + "version": "3.10.9" }, "orig_nbformat": 4, "vscode": { diff --git a/utils.py b/utils.py index 184c6f1..31b89cf 100755 --- a/utils.py +++ b/utils.py @@ -23,6 +23,7 @@ import numpy as np import gdown from networkx.utils import py_random_state import shutil +from pyvis.network import Network # ------------------------------------------------------------------------# @@ -100,21 +101,15 @@ def download_datasets(): shutil.rmtree(os.path.join("data", "foursquare", "dataset_WWW2019")) shutil.rmtree(os.path.join("data", "foursquare", "__MACOSX")) - os.rename(os.path.join("data", "foursquare", "dataset_WWW_friendship_new.txt"), os.path.join("data", "foursquare", "foursquare_friends_edges.txt")) - - os.rename(os.path.join("data", "foursquare", "dataset_WWW_Checkins_anonymized.txt"), os.path.join("data", "foursquare", "foursquare_checkins.txt")) + os.rename(os.path.join("data", "foursquare", "dataset_WWW_Checkins_anonymized.txt"), os.path.join("data", "foursquare", "foursquare_checkins_full.txt")) ## BRIGHTKITE CLEANING ## - - os.rename(os.path.join("data", "brightkite", "loc-brightkite_totalCheckins.txt"), os.path.join("data", "brightkite", "brightkite_checkins.txt")) - + os.rename(os.path.join("data", "brightkite", "loc-brightkite_totalCheckins.txt"), os.path.join("data", "brightkite", "brightkite_checkins_full.txt")) os.rename(os.path.join("data", "brightkite", "loc-brightkite_edges.txt"), os.path.join("data", "brightkite", "brightkite_friends_edges.txt")) ## GOWALLA CLEANING ## - - os.rename(os.path.join("data", "gowalla", "loc-gowalla_totalCheckins.txt"), os.path.join("data", "gowalla", "gowalla_checkins.txt")) - + os.rename(os.path.join("data", "gowalla", "loc-gowalla_totalCheckins.txt"), os.path.join("data", "gowalla", "gowalla_checkins_full.txt")) os.rename(os.path.join("data", "gowalla", "loc-gowalla_edges.txt"), os.path.join("data", "gowalla", "gowalla_friends_edges.txt")) # ------------------------------------------------------------------------# @@ -392,7 +387,7 @@ def average_shortest_path(G: nx.Graph, k=None) -> float: ---------- `G` : networkx graph The graph to compute the average shortest path length of. - `k` : int + `k` : float percentage of nodes to remove from the graph. If k is None, the average shortest path length of each connected component is computed using all the nodes of the connected component. Returns @@ -548,3 +543,90 @@ def create_random_graphs(G: nx.Graph, model = None, save = True) -> nx.Graph: print("\tThe file graph has been saved in the folder data/random/watts_strogatz with the syntax watts_strogatz_n_nodes_n_edges.gpickle") return G_random + + +def visualize_graphs(G: nx.Graph, k: float, connected = True): + + """ + Function to visualize the graph in a HTML page using pyvis + + Parameters + ---------- + G: nx.Graph + The graph to visualize + + k: float + The percentage of nodes to remove from the graph. Default is None, in which case it will be chosen such that there are about 1000 nodes in the sampled graph. I strongly suggest to use the default value, other wise the visualization will be very slow. + + connected: bool + If True, we will consider only the largest connected component of the graph + + Returns + ------- + html file + The html file containing the visualization of the graph + + Notes: + ------ + This is of course an approximation, it's nice to have an idea of the graph, but it's not a good idea trying to understand the graph in details from this sampled visualization. + """ + + if k is None: + if len(G.nodes) > 1500: + k = 1 - 1500/len(G.nodes) + else: + k = 0 + + # remove a percentage of the nodes + nodes_to_remove = np.random.choice(list(G.nodes), size=int(k*len(G.nodes)), replace=False) + G.remove_nodes_from(nodes_to_remove) + + if connected: + # take only the largest connected component + connected_components = list(nx.connected_components(G)) + largest_connected_component = max(connected_components, key=len) + G = G.subgraph(largest_connected_component) + + + # create a networkx graph + net = net = Network(directed=False, bgcolor='#1e1f29', font_color='white') + + # for some reasons, if I put % values, the graph is not displayed correctly. So I use pixels, sorry non FHD users + net.width = '1920px' + net.height = '1080px' + + # add nodes and edges + net.add_nodes(list(G.nodes)) + net.add_edges(list(G.edges)) + + # set the physics layout of the network + net.set_options(""" + var options = { + "edges": { + "color": { + "inherit": true + }, + "smooth": false + }, + "physics": { + "repulsion": { + "centralGravity": 0.25, + "nodeDistance": 500, + "damping": 0.67 + }, + "maxVelocity": 48, + "minVelocity": 0.39, + "solver": "repulsion" + } + } + """) + + name = G.name.replace(" ", "_").lower() + + if not os.path.exists("html_graphs"): + os.mkdir("html_graphs") + + # save the graph in a html file + net.show("html_graphs/{}.html".format(name)) + + print("The graph has been saved in the folder html_graphs with the name {}.html" .format(name))