temporal_graphs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "671a7f5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tg_plots\n",
    "import graph_io\n",
    "import utils\n",
    "import sampling\n",
    "import generators\n",
    "import temporal_graph\n",
    "\n",
    "import os\n",
    "import math\n",
    "import collections\n",
    "import statistics\n",
    "\n",
    "import powerlaw\n",
    "import scipy.optimize\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pytglib as tgl\n",
    "import seaborn as sns\n",
    "import networkit as nk\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sns.set_theme()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31f16d67",
   "metadata": {},
   "source": [
    "temporal clustering with y-axis log scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00aeafb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import ticker as mticker\n",
    "\n",
    "data = pd.read_csv(\"data/graphs_stats/random_from_real_world.csv\").query(\"temp_Clustering > 0\")\n",
    "\n",
    "data[\"temp_Clustering\"] = data[\"temp_Clustering\"].map(np.log10)\n",
    "\n",
    "sns.catplot(data, x=\"Kategorie\", y=\"temp_Clustering\", kind=\"violin\", height=5, aspect=2)\n",
    "\n",
    "ax = plt.gca()\n",
    "ax.yaxis.set_major_formatter(mticker.StrMethodFormatter(\"$10^{{{x:.0f}}}$\"))\n",
    "ymin, ymax = ax.get_ylim()\n",
    "tick_range = np.arange(np.floor(ymin), 1)\n",
    "ax.yaxis.set_ticks(tick_range)\n",
    "ax.yaxis.set_ticks([np.log10(x) for p in tick_range for x in np.linspace(10 **p, 10 **(p + 1), 10)], minor=True)\n",
    "\n",
    "plt.xlabel(\"Graph Kategorie\")\n",
    "plt.ylabel(\"temporales Clustering\")\n",
    "plt.savefig(\"data/graphics/temp_clustering.pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "06f555a6",
   "metadata": {},
   "source": [
    "Plot a single graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b30296f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"data/temporal_graphs/communication/Enron.edges\"\n",
    "\n",
    "tg_plots.edge_cardinality_distribution(path)\n",
    "plt.xlabel(\"Kanten-Kardinalität\")\n",
    "plt.ylabel(\"Anzahl\")\n",
    "plt.show()\n",
    "\n",
    "tg_plots.timestamp_distribution(path, artifacts=0.45, scatter=False)\n",
    "plt.xlabel(\"Zeitstempel\")\n",
    "plt.ylabel(\"Anzahl\")\n",
    "plt.show()\n",
    "\n",
    "tg_plots.degree_distribution(path)\n",
    "plt.xlabel(\"Grad\")\n",
    "plt.ylabel(\"Anzahl\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cff66f0d",
   "metadata": {},
   "source": [
    "Plot all graphs of a category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fa7fb72",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.plot_graphs(tg_plots.TemporalGraphCategories.SOCIAL_MEDIA_GRAPHS, tg_plots.edge_cardinality_distribution, x_label=\"Kardinalität\", y_label=\"Anzahl\", ncols=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c0350fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.plot_graphs(tg_plots.TemporalGraphCategories.SOCIAL_MEDIA_GRAPHS, tg_plots.timestamp_distribution, x_label=\"Zeitstempel\", y_label=\"Anzahl\", ncols=2, plot_width=10, artifacts=0.45, scatter=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.plot_graphs(tg_plots.TemporalGraphCategories.SOCIAL_MEDIA_GRAPHS, tg_plots.degree_distribution, x_label=\"Grad\", y_label=\"Anzahl\", ncols=4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "85465d10",
   "metadata": {},
   "source": [
    "Calculate stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cc9a16f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.stats(tg_plots.iter_temporal_graphs(tg_plots.TemporalGraphCategories.values(), return_type=True), directed=lambda x: False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49c40610",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder = \"edge_exponent_test\"\n",
    "folders = map(lambda x: os.path.join(folder, x), os.listdir(f\"data/temporal_graphs/{folder}\"))\n",
    "tg_plots.stats(tg_plots.iter_temporal_graphs(folders, return_type=True), directed=lambda x: False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c931b05d",
   "metadata": {},
   "source": [
    "Plot stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bcabed9",
   "metadata": {},
   "outputs": [],
   "source": [
    "outside_legend=False\n",
    "aspect = 2\n",
    "\n",
    "# temporal metrics\n",
    "tg_plots.avg_reachability(outside_legend)\n",
    "tg_plots.avg_reachability_ratio(outside_legend)\n",
    "tg_plots.temporal_diameter(outside_legend)\n",
    "tg_plots.temporal_correlation_coefficient(aspect)\n",
    "tg_plots.temporal_clustering(aspect)\n",
    "tg_plots.edge_cardinality_exponent(aspect)\n",
    "\n",
    "# static metrics\n",
    "tg_plots.avg_degree(outside_legend)\n",
    "tg_plots.assortativity(aspect)\n",
    "tg_plots.static_clustering(aspect)\n",
    "tg_plots.degree_exponent(aspect)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61f13890",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.connected_components()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d89d9b5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(tg_plots.GRAPH_STATS_PATH).query(\"Erreichbarkeit > 0\")\n",
    "\n",
    "sns.scatterplot(data, x=\"Knoten\", y=\"Erreichbarkeit\", hue=\"Zufallsgraph\", style=\"Kategorie\")\n",
    "# plt.plot(*zip(*[(x, x) for x in range(1, max(data[\"Knoten\"]))]), label=\"n\")\n",
    "plt.loglog()\n",
    "plt.xlabel(\"Knoten\")\n",
    "plt.ylabel(\"durchschnittliche Erreichbarkeit\")\n",
    "tg_plots.show_legend(True)\n",
    "# plt.savefig(\"data/graphics/reachability.pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8fbde4f9",
   "metadata": {},
   "source": [
    "Erdős–Rényi Graphs: connected component and giant component"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "959ccb0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for path in tg_plots.iter_temporal_graphs(tg_plots.TemporalGraphCategories.values()):\n",
    "    graph = graph_io.read_temporal_graph(path, directed=False, static=True)\n",
    "    n = graph.numberOfNodes()\n",
    "    m = graph.numberOfEdges()\n",
    "    p = (2 * m) / (n * (n - 1))\n",
    "    print(utils.file_name(path).replace(\"_\", \" \"), n, m, \"Ja\" if n * p > 1 else \"Nein\", \"Ja\" if n * p > math.log(n) else \"Nein\", sep=\" & \", end=\" \\\\\\\\\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e21c9c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "\n",
    "for category in tg_plots.TemporalGraphCategories.values():\n",
    "    giant_component = 0\n",
    "    connected = 0\n",
    "    for path in tg_plots.iter_temporal_graphs([category]):\n",
    "        graph = graph_io.read_temporal_graph(path, directed=False, static=True)\n",
    "        n = graph.numberOfNodes()\n",
    "        m = graph.numberOfEdges()\n",
    "        p = (2 * m) / (n * (n - 1))\n",
    "\n",
    "        giant_component += n * p > 1\n",
    "        connected += p > math.log(n) / n\n",
    "\n",
    "    print(category, giant_component, connected)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83650a0f",
   "metadata": {},
   "source": [
    "Havel-Hakimi connected components"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8529f5f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_path = \"data/temporal_graphs/random_from_real_world/havel-hakimi/\"\n",
    "\n",
    "components_data = []\n",
    "\n",
    "for path in sorted(os.listdir(folder_path)):\n",
    "    file_path = os.path.join(folder_path, path)\n",
    "    # directed = tg_plots.is_directed(file_path.replace(\"-random\", \"\"))\n",
    "    directed = False\n",
    "\n",
    "    graph = graph_io.read_temporal_graph(file_path, directed=directed, static=True)\n",
    "    number_of_components = None\n",
    "    largest_component = None\n",
    "\n",
    "    if graph.numberOfNodes() > 1_000_000:\n",
    "        continue\n",
    "\n",
    "    if directed:\n",
    "        scc = nk.components.StronglyConnectedComponents(graph).run()\n",
    "        partition = scc.getPartition()\n",
    "        indexes = sorted(set(partition.getVector()))\n",
    "        largest_component = max(len(partition.getMembers(cmp)) for cmp in indexes)\n",
    "        number_of_components = scc.numberOfComponents()\n",
    "    else:\n",
    "        cc = nk.components.ConnectedComponents(graph).run()\n",
    "        largest_component = cc.extractLargestConnectedComponent(graph, True).numberOfNodes()\n",
    "        number_of_components = cc.numberOfComponents()\n",
    "\n",
    "    print(path, directed, number_of_components, graph.numberOfNodes(), largest_component, round(largest_component / graph.numberOfNodes(), 2))\n",
    "\n",
    "    components_data.append([graph.numberOfNodes(), number_of_components, largest_component])\n",
    "\n",
    "components_data = pd.DataFrame(components_data, columns=[\"Nodes\", \"Components\", \"Largest-Component\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eff1aa3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "components_data[\"Ratio\"] = components_data[\"Largest-Component\"] / components_data[\"Nodes\"]\n",
    "\n",
    "sns.scatterplot(data=components_data, x=\"Nodes\", y=\"Ratio\")\n",
    "plt.xscale(\"log\")\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel(\"Knoten\")\n",
    "plt.ylabel(\"Anteil der größten Zusammenhangskomponente\")\n",
    "plt.savefig(\"data/graphics/random/largest-component.pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00db2ba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(components_data[\"Ratio\"].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e639079b",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.scatterplot(data=components_data, x=\"Nodes\", y=\"Components\")\n",
    "plt.loglog()\n",
    "plt.xlabel(\"Knoten\")\n",
    "plt.ylabel(\"Zusammenhangskomponenten\")\n",
    "plt.savefig(\"data/graphics/random/number_of_components.pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "814fb91a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, a):\n",
    "    return a * x\n",
    "\n",
    "components_data.sort_values(by=[\"Nodes\"], inplace=True)\n",
    "\n",
    "popt, _ = scipy.optimize.curve_fit(func, components_data[\"Nodes\"], components_data[\"Components\"])\n",
    "print(popt)\n",
    "\n",
    "sns.scatterplot(components_data, x=\"Nodes\", y=\"Components\")\n",
    "plt.plot(components_data[\"Nodes\"], func(components_data[\"Nodes\"], *popt), label=\"fit\")\n",
    "plt.loglog()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e106013",
   "metadata": {},
   "source": [
    "Chung-Lu isolated nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "505ce07d",
   "metadata": {},
   "outputs": [],
   "source": [
    "real_world_stats = pd.read_csv(\"data/graphs_stats/real_world.csv\")\n",
    "random_stats = pd.read_csv(\"data/graphs_stats/random_from_real_world.csv\").query(\"Kategorie == 'Chung-Lu'\")\n",
    "\n",
    "def get_number_of_nodes(dataset):\n",
    "    dataset = dataset.replace(\"-random\", \"\")\n",
    "    return real_world_stats.query(f\"Datensatz == @dataset\")[\"Knoten\"].iloc[0]\n",
    "\n",
    "\n",
    "random_stats[\"Knoten_Original\"] = random_stats[\"Datensatz\"].map(get_number_of_nodes)\n",
    "random_stats[\"Isoliert\"] = random_stats[\"Knoten_Original\"] - random_stats[\"Knoten\"]\n",
    "random_stats[\"Anteil\"] = random_stats[\"Isoliert\"] / random_stats[\"Knoten_Original\"]\n",
    "\n",
    "print(random_stats[\"Anteil\"].mean())\n",
    "\n",
    "sns.scatterplot(data=random_stats, x=\"Knoten_Original\", y=\"Anteil\")\n",
    "plt.xscale(\"log\")\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel(\"Knoten\")\n",
    "plt.ylabel(\"Anteil der isolierten Knoten\")\n",
    "plt.savefig(\"data/graphics/random/isolated.pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c9b270e",
   "metadata": {},
   "source": [
    "Generate random temporal graphs from real world temporal graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12734ba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_path = os.path.join(tg_plots.TEMPORAL_GRAPHS_PATH, \"random_from_real_world\", \"havel-hakimi\")\n",
    "\n",
    "for network_type, path in tg_plots.iter_temporal_graphs(tg_plots.TemporalGraphCategories.values(), return_type=True):\n",
    "    # if \"MIT_Reality_Mining\" in path: continue\n",
    "\n",
    "    edges = generators.havel_hakimi_tg_from_graph(path, tg_plots.is_directed(path))\n",
    "    random_graph_path = os.path.join(folder_path f\"{utils.file_name(path)}-random.edges\")\n",
    "    graph_io.write_edge_list(random_graph_path, edges)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c42e65a7",
   "metadata": {},
   "source": [
    "Time interval experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "259daff3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for days in [1, 10, 20]:\n",
    "    # folder_path = f\"data/temporal_graphs/time_interval_test/chung-lu_waves_{days}\"\n",
    "    folder_path = f\"data/temporal_graphs/time_interval_test/hyperbolic_waves_{days}\"\n",
    "\n",
    "    if not os.path.exists(folder_path):\n",
    "        os.makedirs(folder_path)\n",
    "\n",
    "    for i, n in enumerate(utils.node_count_iterator(100, 20_000)):\n",
    "        timestamps_per_day = 24\n",
    "        timestamps = days * timestamps_per_day\n",
    "        timestamp_weights = sampling.generate_burst_weights(days, timestamps_per_day // 2)\n",
    "\n",
    "        cardinality_distribution = sampling.Zipf(2, timestamps)\n",
    "\n",
    "        G = nk.generators.HyperbolicGenerator(n, 10, 2.5).generate()\n",
    "\n",
    "        # degree_seq = nk.generators.PowerlawDegreeSequence(1, n - 1, -2.5).run().getDegreeSequence(n)\n",
    "        # G = nk.generators.ChungLuGenerator(degree_seq).generate()\n",
    "\n",
    "        edges = generators.temporal_graph_generator(G, cardinality_distribution, timestamp_weights)\n",
    "        path = os.path.join(folder_path, f\"{i:02d}.edges\")\n",
    "        graph_io.write_edge_list(path, edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "577f2efc",
   "metadata": {},
   "outputs": [],
   "source": [
    "for timestamps in [1, 2, 5, 10, 50, 100, 200]:\n",
    "    # folder_path = f\"data/temporal_graphs/time_interval_test/chung-lu_uniform_{timestamps}\"\n",
    "    folder_path = f\"data/temporal_graphs/time_interval_test/hyperbolic_uniform_{timestamps}\"\n",
    "\n",
    "    if not os.path.exists(folder_path):\n",
    "        os.makedirs(folder_path)\n",
    "\n",
    "    for i, n in enumerate(utils.node_count_iterator(100, 20_000)):\n",
    "        timestamp_weights = [1] * timestamps\n",
    "        \n",
    "        cardinality_distribution = sampling.Zipf(2, timestamps)\n",
    "\n",
    "        G = nk.generators.HyperbolicGenerator(n, 10, 2.5).generate()\n",
    "\n",
    "        # degree_seq = nk.generators.PowerlawDegreeSequence(1, n - 1, -2.5).run().getDegreeSequence(n)\n",
    "        # G = nk.generators.ChungLuGenerator(degree_seq).generate()\n",
    "\n",
    "        edges = generators.temporal_graph_generator(G, cardinality_distribution, timestamp_weights)\n",
    "        path = os.path.join(folder_path, f\"{i:02d}.edges\")\n",
    "        graph_io.write_edge_list(path, edges)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388cb373",
   "metadata": {},
   "source": [
    "Avg. degree experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85a43fa2",
   "metadata": {},
   "outputs": [],
   "source": [
    "for avg_degree in [2, 4, 7, 10, 15]:\n",
    "    folder_path = f\"data/temporal_graphs/avg_degree_test/avg-degree-{avg_degree}\"\n",
    "\n",
    "    if not os.path.exists(folder_path):\n",
    "        os.makedirs(folder_path)\n",
    "\n",
    "    for i, n in enumerate(utils.node_count_iterator(100, 20_000)):\n",
    "        timestamps = 100_000\n",
    "        timestamp_weights = [1] * timestamps\n",
    "        \n",
    "        cardinality_distribution = sampling.Zipf(2, timestamps)\n",
    "\n",
    "        G = nk.generators.HyperbolicGenerator(n, avg_degree, 2.5).generate()\n",
    "\n",
    "        edges = generators.temporal_graph_generator(G, cardinality_distribution, timestamp_weights)\n",
    "        path = os.path.join(folder_path, f\"{i:02d}.edges\")\n",
    "        graph_io.write_edge_list(path, edges)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "116992fc",
   "metadata": {},
   "source": [
    "Edge cardinalities exponent experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fe23d18",
   "metadata": {},
   "outputs": [],
   "source": [
    "for min_c, exp in [(1, 1.5), (30, 2.0), (83, 2.5)]:\n",
    "    folder_path = f\"data/temporal_graphs/edge_exponent_test/hyperbolic_{exp}\"\n",
    "\n",
    "    if not os.path.exists(folder_path):\n",
    "        os.makedirs(folder_path)\n",
    "\n",
    "    for i, n in enumerate(utils.node_count_iterator(100, 20_000)):\n",
    "        timestamps = range(100_000)\n",
    "        timestamp_weights = [1] * len(timestamps)\n",
    "\n",
    "        G = nk.generators.HyperbolicGenerator(n, 10, 2.5).generate()\n",
    "\n",
    "        sampler = sampling.Hybrid(timestamps, timestamp_weights)\n",
    "        cardinalities = nk.generators.PowerlawDegreeSequence(min_c, len(timestamps), -exp).run().getDegreeSequence(G.numberOfEdges())\n",
    "\n",
    "        edges = []\n",
    "        for (u, v), k in zip(G.iterEdges(), cardinalities):\n",
    "            for t in sampler.sample(k):\n",
    "                edges.append((u, v, t))\n",
    "\n",
    "        path = os.path.join(folder_path, f\"{i:02d}.edges\")\n",
    "        graph_io.write_edge_list(path, edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c86dbbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(tg_plots.GRAPH_STATS_PATH)\n",
    "\n",
    "sns.scatterplot(data, x=\"Knoten\", y=\"Kanten\", hue=\"Kategorie\")\n",
    "plt.loglog()\n",
    "plt.savefig(\"data/graphics/edges.pdf\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0453e91",
   "metadata": {},
   "source": [
    "Granularity experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dc39a6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "graph_path = \"data/temporal_graphs/communication/Enron.edges\"\n",
    "folder_path = \"data/temporal_graphs/granularity_test\"\n",
    "\n",
    "for i in range(10):\n",
    "    edges = graph_io.read_edge_list(graph_path)\n",
    "    edges = list({(u,v,t // (10**i), tt) for (u,v,t,tt) in edges})\n",
    "    graph_io.write_edge_list(os.path.join(folder_path, f\"{i}.edges\"), edges)\n",
    "    print(len(edges))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2718378",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_path = \"data/temporal_graphs/granularity_test\"\n",
    "\n",
    "for path in sorted(os.listdir(folder_path)):\n",
    "    tg = temporal_graph.TemporalGraph(os.path.join(folder_path, path), True)\n",
    "    timestamps = tg.timestamps()\n",
    "    print(path, min(timestamps), max(timestamps), max(timestamps) - min(timestamps) + 1, len(set(timestamps)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1e25d85",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.stats(tg_plots.iter_temporal_graphs([\"granularity_test\"], return_type=True), directed=lambda x: True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d18db907",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"data/graphs_stats/granularity_test.csv\")\n",
    "print(data.to_markdown(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fda6c5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "tg_plots.plot_graphs(\"granularity_test\", tg_plots.edge_cardinality_distribution)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9cbea98",
   "metadata": {},
   "source": [
    "Power Law"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdb4878e",
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = nk.generators.PowerlawDegreeSequence(83, 100_000, -2.5).run()\n",
    "print(generator.getExpectedAverageDegree())\n",
    "print(sum(generator.getDegreeSequence(100_000)) / 100_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb36c495",
   "metadata": {},
   "outputs": [],
   "source": [
    "def harmonic_number(n, gamma=1):\n",
    "    return sum(1 / (i**gamma) for i in range(1, n + 1))\n",
    "\n",
    "\n",
    "def expected_value(x_min, x_max, gamma):\n",
    "    return (harmonic_number(x_max, gamma - 1) - harmonic_number(x_min - 1, gamma - 1)) / (harmonic_number(x_max, gamma) - harmonic_number(x_min - 1, gamma))\n",
    "\n",
    "print(expected_value(83, 100_000, 2.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33cfb692",
   "metadata": {},
   "source": [
    "Plot temporal diameter of random graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fbdbaed",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_real_world = pd.read_csv(\"data/graphs_stats/real_world.csv\")\n",
    "data_random = pd.read_csv(\"data/graphs_stats/random_from_real_world.csv\")\n",
    "\n",
    "sns.scatterplot(data_random, x=\"Knoten\", y=\"temp_Durchmesser\", hue=\"Kategorie\")\n",
    "sns.scatterplot(data_real_world, x=\"Knoten\", y=\"temp_Durchmesser\", hue=\"Kategorie\", marker=\"+\", palette=['pink','orange','dodgerblue','red'])\n",
    "plt.plot(*zip(*[(x, math.log2(x)) for x in range(1, max(data_real_world[\"Knoten\"]))]), label=\"log2(n)\")\n",
    "plt.xlabel(\"Knoten\")\n",
    "plt.ylabel(\"temporaler Durchmesser\")\n",
    "plt.legend(bbox_to_anchor=(1.04, 1), loc=\"upper left\")\n",
    "plt.loglog()\n",
    "plt.xlim(10, 10**6)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42756660",
   "metadata": {},
   "source": [
    "Fit temporal diameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "def func(x, base, a, c):\n",
    "    return a* (np.log(x) / np.log(base)) + c\n",
    "\"\"\"\n",
    "def func(x, base):\n",
    "    return np.log(x) / np.log(base)\n",
    "\n",
    "    \n",
    "data = pd.read_csv(\"data/graphs_stats/real_world.csv\").query(\"temp_Durchmesser > 0\")\n",
    "data.sort_values(by=[\"Knoten\"], inplace=True)\n",
    "\n",
    "popt, _ = scipy.optimize.curve_fit(func, data[\"Knoten\"], data[\"temp_Durchmesser\"], bounds=[[1], [20]])\n",
    "print(popt)\n",
    "\n",
    "sns.scatterplot(data, x=\"Knoten\", y=\"temp_Durchmesser\")\n",
    "plt.plot(data[\"Knoten\"], func(data[\"Knoten\"], *popt), label=\"fit\")\n",
    "plt.plot(*zip(*[(x, math.log(x, 2)) for x in range(1, max(data[\"Knoten\"]))]), label=\"log2(n)\")\n",
    "plt.loglog()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "174351e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, k):\n",
    "    return np.power(x, k)\n",
    "\n",
    "data = pd.read_csv(\"data/graphs_stats/real_world.csv\").query(\"Erreichbarkeit > 0\")\n",
    "data.sort_values(by=[\"Knoten\"], inplace=True)\n",
    "\n",
    "popt, _ = scipy.optimize.curve_fit(func, data[\"Knoten\"], data[\"Erreichbarkeit\"])\n",
    "print(popt)\n",
    "\n",
    "sns.scatterplot(data, x=\"Knoten\", y=\"Erreichbarkeit\")\n",
    "plt.plot(data[\"Knoten\"], func(data[\"Knoten\"], *popt), label=\"fit\")\n",
    "plt.loglog()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98bff0e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_real_world = pd.read_csv(\"data/graphs_stats/real_world.csv\").query(\"temp_Durchmesser > 0\")\n",
    "data_random = pd.read_csv(\"data/graphs_stats/random_from_real_world.csv\").query(\"temp_Durchmesser > 0\")\n",
    "\n",
    "def get_real_world_diameter(dataset):\n",
    "    dataset = dataset.replace(\"-random\", \"\")\n",
    "    return data_real_world.query(f\"Datensatz == @dataset\")[\"temp_Durchmesser\"].iloc[0]\n",
    "\n",
    "\n",
    "data_random[\"beobachtet_Durchmesser\"] = data_random[\"Datensatz\"].map(get_real_world_diameter)\n",
    "data_random[\"Verhaeltnis\"] = data_random[\"temp_Durchmesser\"] / data_random[\"beobachtet_Durchmesser\"]\n",
    "\n",
    "sns.catplot(data_random, x=\"Kategorie\", y=\"Verhaeltnis\", kind=\"violin\", height=5, aspect=2)\n",
    "plt.yticks([0, 1, 2, 3, 6, 9, 12, 15])\n",
    "plt.ylim(0, 15)\n",
    "plt.xlabel(\"Graph Kategorie\")\n",
    "plt.ylabel(\"Verhältnis\")\n",
    "plt.savefig(\"data/graphics/diameter_comparison.pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7944d789",
   "metadata": {},
   "source": [
    "Real world graphs nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a981ef9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"data/graphs_stats/real_world.csv\")\n",
    "\n",
    "for category in np.unique(data[\"Kategorie\"]):\n",
    "    data_category = data.query(\"Kategorie == @category\")\n",
    "    print(category, data_category[\"Knoten\"].min(), data_category[\"Knoten\"].max(), data_category[\"Knoten\"].median())"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}