get_stats.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from os.path import dirname, join\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import xgi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_name = \"recipe-rec\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"index.json\") as file:\n",
    "    jsondata = json.load(file)\n",
    "baseurl = jsondata[dataset_name][\"url\"]\n",
    "\n",
    "try:\n",
    "    H = xgi.from_hif_dict(xgi.request_json_from_url(baseurl))\n",
    "except KeyError:\n",
    "    if (\n",
    "        \"data-type\" in jsondata[dataset_name]\n",
    "        and jsondata[dataset_name][\"data-type\"] == \"collection\"\n",
    "    ):\n",
    "        H = {}\n",
    "        stats = {\"datasets\": {}}\n",
    "        for key, data in xgi.request_json_from_url(baseurl)[\"datasets\"].items():\n",
    "            relpath = data[\"relative-path\"]\n",
    "            url = join(dirname(baseurl), relpath)\n",
    "            H[key] = xgi.from_hypergraph_dict(xgi.request_json_from_url(url))\n",
    "            stats[\"datasets\"][key] = {\"url\": url}\n",
    "    else:\n",
    "        H = xgi.from_hypergraph_dict(xgi.request_json_from_url(baseurl))\n",
    "        stats = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "if isinstance(H, xgi.Hypergraph):\n",
    "    stats.update(\n",
    "        {\n",
    "            \"num-nodes\": int(H.num_nodes),\n",
    "            \"num-edges\": int(H.num_edges),\n",
    "        }\n",
    "    )\n",
    "elif isinstance(H, dict):\n",
    "    for key, net in H.items():\n",
    "        stats[\"datasets\"][key].update(\n",
    "            {\n",
    "                \"num-nodes\": int(net.num_nodes),\n",
    "                \"num-edges\": int(net.num_edges),\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "if isinstance(H, xgi.Hypergraph):\n",
    "    simpleH = H.copy()\n",
    "    simpleH.merge_duplicate_edges()\n",
    "    stats.update(\n",
    "        {\n",
    "            \"num-unique-edges\": int(simpleH.num_edges),\n",
    "        }\n",
    "    )\n",
    "elif isinstance(H, dict):\n",
    "    for key, net in H.items():\n",
    "        simpleH = net.copy()\n",
    "        simpleH.merge_duplicate_edges()\n",
    "        stats[\"datasets\"][key].update(\n",
    "            {\n",
    "                \"num-unique-edges\": int(simpleH.num_edges),\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "if isinstance(H, xgi.Hypergraph):\n",
    "    s = H.edges.size\n",
    "    stats.update(\n",
    "        {\n",
    "            \"min-edge-size\": int(s.min()),\n",
    "            \"max-edge-size\": int(s.max()),\n",
    "            \"mean-edge-size\": round(s.mean(), 2),\n",
    "        }\n",
    "    )\n",
    "elif isinstance(H, dict):\n",
    "    for key, net in H.items():\n",
    "        s = net.edges.size\n",
    "        stats[\"datasets\"][key].update(\n",
    "            {\n",
    "                \"min-edge-size\": int(s.min()),\n",
    "                \"max-edge-size\": int(s.max()),\n",
    "                \"mean-edge-size\": round(s.mean(), 2),\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "if isinstance(H, xgi.Hypergraph):\n",
    "    d = H.nodes.degree\n",
    "    stats.update(\n",
    "        {\n",
    "            \"min-degree\": int(d.min()),\n",
    "            \"max-degree\": int(d.max()),\n",
    "            \"mean-degree\": round(d.mean(), 2),\n",
    "        }\n",
    "    )\n",
    "elif isinstance(H, dict):\n",
    "    for key, net in H.items():\n",
    "        d = net.nodes.degree\n",
    "        stats[\"datasets\"][key].update(\n",
    "            {\n",
    "                \"min-degree\": int(s.min()),\n",
    "                \"max-degree\": int(d.max()),\n",
    "                \"mean-degree\": round(d.mean(), 2),\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "if isinstance(H, xgi.Hypergraph):\n",
    "    cc = [len(c) for c in xgi.connected_components(H)]\n",
    "    stats.update(\n",
    "        {\n",
    "            \"num-components\": len(cc),\n",
    "            \"gc-size\": max(cc),\n",
    "        }\n",
    "    )\n",
    "elif isinstance(H, dict):\n",
    "    for key, net in H.items():\n",
    "        cc = [len(c) for c in xgi.connected_components(net)]\n",
    "        stats[\"datasets\"][key].update(\n",
    "            {\n",
    "                \"num-components\": len(cc),\n",
    "                \"gc-size\": max(cc),\n",
    "            }\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"index.json\") as file:\n",
    "    data = json.load(file)\n",
    "\n",
    "data[dataset_name].update(stats)\n",
    "\n",
    "datastring = json.dumps(data, indent=2)\n",
    "\n",
    "with open(\"index.json\", \"w\") as output_file:\n",
    "    output_file.write(datastring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_distributions(\n",
    "    H,\n",
    "    node_bins=None,\n",
    "    edge_bins=None,\n",
    "    log_x1=True,\n",
    "    log_y1=True,\n",
    "    log_x2=True,\n",
    "    log_y2=True,\n",
    "):\n",
    "\n",
    "    if node_bins is None:\n",
    "        node_bins = int(H.num_nodes / 20)\n",
    "        node_bins = min(node_bins, 100)\n",
    "\n",
    "    if edge_bins is None:\n",
    "        s = H.edges.size\n",
    "        edge_bins = int(s.max() - s.min() + 1)\n",
    "        edge_bins = min(edge_bins, 100)\n",
    "\n",
    "    plt.figure(figsize=(8, 4))\n",
    "    plt.subplot(121)\n",
    "\n",
    "    h1 = H.nodes.degree.ashist(bins=node_bins, density=True, log_binning=log_x1)\n",
    "    h2 = H.edges.size.ashist(bins=edge_bins, density=True, log_binning=log_x2)\n",
    "    y1 = h1[h1.value > 0].value\n",
    "    y2 = h2[h2.value > 0].value\n",
    "    ymin = 0.95 * min(y1.min(), y2.min())\n",
    "    ymax = 1.1 * max(y1.max(), y2.max())\n",
    "\n",
    "    if log_x1 and log_y1:\n",
    "        plt.loglog(h1[\"bin_center\"], h1[\"value\"], \"ko\", markersize=2)\n",
    "    elif log_x1 and not log_y1:\n",
    "        plt.semilogx(h1[\"bin_center\"], h1[\"value\"], \"ko\", markersize=2)\n",
    "    elif not log_x1 and log_y1:\n",
    "        plt.semilogy(h1[\"bin_center\"], h1[\"value\"], \"ko\", markersize=2)\n",
    "    elif not log_x1 and not log_y1:\n",
    "        plt.plot(h1[\"bin_center\"], h1[\"value\"], \"ko\", markersize=2)\n",
    "\n",
    "    plt.title(\"Degree distribution\")\n",
    "    plt.xlabel(r\"$k$\", fontsize=16)\n",
    "    plt.ylabel(r\"$P(k)$\", fontsize=16)\n",
    "    plt.ylim([ymin, ymax])\n",
    "    sns.despine()\n",
    "\n",
    "    plt.subplot(122)\n",
    "\n",
    "    if log_x2 and log_y2:\n",
    "        plt.loglog(h2[\"bin_center\"], h2[\"value\"], \"ko\", markersize=2)\n",
    "    elif log_x2 and not log_y2:\n",
    "        plt.semilogx(h2[\"bin_center\"], h2[\"value\"], \"ko\", markersize=2)\n",
    "    elif not log_x2 and log_y2:\n",
    "        plt.semilogy(h2[\"bin_center\"], h2[\"value\"], \"ko\", markersize=2)\n",
    "    elif not log_x2 and not log_y2:\n",
    "        plt.plot(h2[\"bin_center\"], h2[\"value\"], \"ko\", markersize=2)\n",
    "\n",
    "    plt.title(\"Edge size distribution\")\n",
    "    plt.xlabel(r\"$s$\", fontsize=16)\n",
    "    plt.ylabel(r\"$P(s)$\", fontsize=16)\n",
    "    plt.ylim([ymin, ymax])\n",
    "    sns.despine()\n",
    "    plt.tight_layout()\n",
    "    Path(f\"datasheets/{dataset_name}\").mkdir(parents=True, exist_ok=True)\n",
    "    plt.savefig(f\"datasheets/{dataset_name}/stats.png\", dpi=300)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_distributions(H, log_x1=True, log_y1=True, log_x2=True, log_y2=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "xgi",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}