tutorials/Tutorial 6 - Statistics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9d820f8e",
   "metadata": {},
   "source": [
    "# Tutorial 6 - Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22c91ad1",
   "metadata": {},
   "source": [
    "You may have noticed that most of the functionality in the `Hypergraph` and `SimplicialComplex` classes takes care of modifying the unerlying structure of the network, and that these classes provide very limited functionality to compute statistics (a.k.a. measures) from the network. This is done via the `stats` package, explored here.\n",
    "\n",
    "The stats package is one of the features that sets `xgi` apart from other libraries.  It\n",
    "provides a common interface to all statistics that can be computed from a network, its\n",
    "nodes, or edges."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "018c6bd1",
   "metadata": {},
   "source": [
    "## Introduction to Stat objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ab63954",
   "metadata": {},
   "source": [
    "Consider the degree of the nodes of a network `H`.  After computing the values of the\n",
    "degrees, one may wish to store them in a dict, a list, an array, a dataframe, etc.\n",
    "Through the stats package, `xgi` provides a simple interface that seamlessly allows for\n",
    "this type conversion.  This is done via the `NodeStat` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "05a9a2a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeStat('degree')"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import xgi\n",
    "\n",
    "H = xgi.Hypergraph([[1, 2, 3], [2, 3, 4, 5], [3, 4, 5]])\n",
    "H.nodes.degree"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c456800",
   "metadata": {},
   "source": [
    "This `NodeStat` object is essentially a wrapper over a function that computes the\n",
    "degrees of all nodes.  One of the main features of `NodeStat` objects is lazy\n",
    "evaluation: `H.nodes.degree` will not compute the degrees of nodes until a specific\n",
    "output format is requested."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "512f4e2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1, 2: 2, 3: 3, 4: 2, 5: 2}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree.asdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ddaed7f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 2, 2]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree.aslist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "738297c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 2, 2])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree.asnumpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5958e119",
   "metadata": {},
   "source": [
    "To compute the degrees of a subset of the nodes, call `degree` from a smaller `NodeView`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5c19ec0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: 3, 4: 2, 5: 2}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes([3, 4, 5]).degree.asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c271d46",
   "metadata": {},
   "source": [
    "The order of the degrees in the output respects the order of the nodes in the underlying\n",
    "view."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "01837d9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([3, 2, 2], [3, 2, 2])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes([3, 4, 5]).degree.aslist(), H.nodes([4, 3, 5]).degree.aslist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaf82dff",
   "metadata": {},
   "source": [
    "Alternatively, to compute the degree of a single node, use square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "64eda1dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0cfd41c",
   "metadata": {},
   "source": [
    "Make sure the accessed node is in the underlying view."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2a745586",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will raise an exception\n",
    "# because node 4 is not in the view [1, 2, 3]\n",
    "#\n",
    "# H.nodes([1, 2, 3]).degree[4]\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41ee1b35",
   "metadata": {},
   "source": [
    "args and kwargs may be passed to `NodeStat` objects, which will be stored and used when\n",
    "the evaluation finally takes place.  For example, use the `order` keyword of `degree` to\n",
    "count only those edges of the specified order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "06f97c51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeStat('degree', kwargs={'order': 3})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree(order=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d78bcb31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree(order=3).aslist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547ceda2",
   "metadata": {},
   "source": [
    "The stats package provides some convenience functions for numerical operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "48bb7d5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.degree.max(), H.nodes.degree.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8490f605",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.   , 0.   , 0.667, 1.   , 0.222, 0.471])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "st = H.nodes([1, 2, 3]).degree(order=3)\n",
    "np.round([st.max(), st.min(), st.mean(), st.median(), st.var(), st.std()], 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7669ae88",
   "metadata": {},
   "source": [
    "As a convenience, each node statistic may also be accessed directly through the network itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3b0797f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1, 2: 2, 3: 3, 4: 2, 5: 2}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.degree()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39d32e77",
   "metadata": {},
   "source": [
    "Note however that `H.degree` is a method that simply returns a dict, not a `NodeStat` object and thus does not support the features discussed above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08163646",
   "metadata": {},
   "source": [
    "## Node attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9152e7e5",
   "metadata": {},
   "source": [
    "Node attributes can be conceived of as a node-object mapping and thus they can also be accessed using the `NodeStat` interface and all its funcitonality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6215e577",
   "metadata": {},
   "outputs": [],
   "source": [
    "H.add_nodes_from(\n",
    "    [\n",
    "        (1, {\"color\": \"red\", \"name\": \"horse\"}),\n",
    "        (2, {\"color\": \"blue\", \"name\": \"pony\"}),\n",
    "        (3, {\"color\": \"yellow\", \"name\": \"zebra\"}),\n",
    "        (4, {\"color\": \"red\", \"name\": \"orangutan\", \"age\": 20}),\n",
    "        (5, {\"color\": \"blue\", \"name\": \"fish\", \"age\": 2}),\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54a3a925",
   "metadata": {},
   "source": [
    "Access all attributes of all nodes by specifying a return type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3053f165",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'color': 'red', 'name': 'horse'},\n",
       " 2: {'color': 'blue', 'name': 'pony'},\n",
       " 3: {'color': 'yellow', 'name': 'zebra'},\n",
       " 4: {'color': 'red', 'name': 'orangutan', 'age': 20},\n",
       " 5: {'color': 'blue', 'name': 'fish', 'age': 2}}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.attrs.asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "052ed6b4",
   "metadata": {},
   "source": [
    "Access all attributes of a single node by using square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "58b9c28b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'color': 'red', 'name': 'horse'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.attrs[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f91502a",
   "metadata": {},
   "source": [
    "Access a single attribute of all nodes by specifying a return type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f7dfa2d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'blue', 'yellow', 'red', 'blue']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.attrs(\"color\").aslist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce1a5c97",
   "metadata": {},
   "source": [
    "If a node does not have the specified attribute, `None` will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "c2a5acff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: None, 2: None, 3: None, 4: 20, 5: 2}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.attrs(\"age\").asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f6c2981",
   "metadata": {},
   "source": [
    "Use the `missing` keyword argument to change the imputed value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d9b9ea5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 100, 2: 100, 3: 100, 4: 20, 5: 2}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.attrs(\"age\", missing=100).asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac5342bf",
   "metadata": {},
   "source": [
    "## Filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8feadac",
   "metadata": {},
   "source": [
    "`NodeView` objects are aware of existing `NodeStat` objects via the `filterby` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5164b23e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1, 2: 2, 3: 3, 4: 2, 5: 2}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.degree()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c0688703",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView((2, 4, 5))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.filterby(\"degree\", 2)  # apply the filter to all nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "302e6674",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView((2,))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes([1, 2, 3]).filterby(\n",
    "    \"degree\", 2\n",
    ")  # apply the filter only to the subset of nodes [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cba86c7",
   "metadata": {},
   "source": [
    "Nodes can be filtered by attribute via the `filterby_attr` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c612ccff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView((1, 4))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.filterby_attr(\"color\", \"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69b855ef",
   "metadata": {},
   "source": [
    "Since `filterby*` methods return a `NodeView` object, multiple filters can be chained, as well as other `NodeStat` calls. The following call computes the local clustering coefficient of those nodes with degree equal to 2 and \"color\" attribute equal to \"blue\", and outputs the result as a dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cbdc4409",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: 4.0, 5: 3.0}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(H.nodes.filterby(\"degree\", 2).filterby_attr(\"color\", \"blue\").clustering.asdict())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d830bb95",
   "metadata": {},
   "source": [
    "For example, here is how to access the nodes with maximum degree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c8defa14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView((3,))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.filterby(\"degree\", H.nodes.degree.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc5df033",
   "metadata": {},
   "source": [
    "## Set operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11548f49",
   "metadata": {},
   "source": [
    "Another way of chaining multiple results of `filterby*` methods is by using set operations. Indeed, chaining two filters is the same as intersecting the results of two separate calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "970da532",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5]\n",
      "[2, 5]\n"
     ]
    }
   ],
   "source": [
    "print(H.nodes.filterby(\"degree\", 2).filterby_attr(\"color\", \"blue\"))\n",
    "print(H.nodes.filterby(\"degree\", 2) & H.nodes.filterby_attr(\"color\", \"blue\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0ff694",
   "metadata": {},
   "source": [
    "Other set operations are also supported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "65c22a67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nodes1 - nodes2 = [4]\n",
      "nodes2 - nodes1 = []\n",
      "nodes1 & nodes2 = [2, 5]\n",
      "nodes1 | nodes2 = [2, 4, 5]\n",
      "nodes1 ^ nodes2 = [4]\n"
     ]
    }
   ],
   "source": [
    "nodes1 = H.nodes.filterby(\"degree\", 2)\n",
    "nodes2 = H.nodes.filterby_attr(\"color\", \"blue\")\n",
    "print(f\"nodes1 - nodes2 = {nodes1 - nodes2}\")\n",
    "print(f\"nodes2 - nodes1 = {nodes2 - nodes1}\")\n",
    "print(f\"nodes1 & nodes2 = {nodes1 & nodes2}\")\n",
    "print(f\"nodes1 | nodes2 = {nodes1 | nodes2}\")\n",
    "print(f\"nodes1 ^ nodes2 = {nodes1 ^ nodes2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "697055d8",
   "metadata": {},
   "source": [
    "## Multiple statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f35e4ef1",
   "metadata": {},
   "source": [
    "One can obtain multiple node statistics at the same time via the `multi` method, which returns `MultiNodeStat` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "09aeadef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultiNodeStat(degree, clustering)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.multi([\"degree\", \"clustering\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "741b381a",
   "metadata": {},
   "source": [
    "Objects of class `MultiNodeStat` also support lazy evaluation and type conversion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "31619b17",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'degree': 1, 'clustering': 0.0},\n",
       " 2: {'degree': 2, 'clustering': 4.0},\n",
       " 3: {'degree': 3, 'clustering': 1.3333333333333333},\n",
       " 4: {'degree': 2, 'clustering': 3.0},\n",
       " 5: {'degree': 2, 'clustering': 3.0}}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.multi([\"degree\", \"clustering\"]).asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdb4bd5",
   "metadata": {},
   "source": [
    "There are more options for the output type of a `MultiNodeStat` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c29d8461",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# dict of dicts, nodes first:\n",
      "{1: {'clustering': 0.0, 'degree': 1},\n",
      " 2: {'clustering': 4.0, 'degree': 2},\n",
      " 3: {'clustering': 1.3333333333333333, 'degree': 3},\n",
      " 4: {'clustering': 3.0, 'degree': 2},\n",
      " 5: {'clustering': 3.0, 'degree': 2}}\n",
      "\n",
      "# dict of dicts, stats first:\n",
      "{'clustering': {1: 0.0, 2: 4.0, 3: 1.3333333333333333, 4: 3.0, 5: 3.0},\n",
      " 'degree': {1: 1, 2: 2, 3: 3, 4: 2, 5: 2}}\n",
      "\n",
      "# dict of lists:\n",
      "{1: [1, 0.0], 2: [2, 4.0], 3: [3, 1.3333333333333333], 4: [2, 3.0], 5: [2, 3.0]}\n",
      "\n",
      "# list of lists, nodes first:\n",
      "[[1, 0.0], [2, 4.0], [3, 1.3333333333333333], [2, 3.0], [2, 3.0]]\n",
      "\n",
      "# list of lists, stats first:\n",
      "[[1, 2, 3, 2, 2], [0.0, 4.0, 1.3333333333333333, 3.0, 3.0]]\n",
      "\n",
      "# list of dicts:\n",
      "[{'clustering': 0.0, 'degree': 1},\n",
      " {'clustering': 4.0, 'degree': 2},\n",
      " {'clustering': 1.3333333333333333, 'degree': 3},\n",
      " {'clustering': 3.0, 'degree': 2},\n",
      " {'clustering': 3.0, 'degree': 2}]\n"
     ]
    }
   ],
   "source": [
    "ms = H.nodes.multi([\"degree\", \"clustering\"])\n",
    "\n",
    "from pprint import pprint\n",
    "\n",
    "print(\"# dict of dicts, nodes first:\")\n",
    "pprint(ms.asdict())\n",
    "print()\n",
    "print(\"# dict of dicts, stats first:\")\n",
    "pprint(ms.asdict(transpose=True))\n",
    "print()\n",
    "print(\"# dict of lists:\")\n",
    "pprint(ms.asdict(list))\n",
    "print()\n",
    "print(\"# list of lists, nodes first:\")\n",
    "pprint(ms.aslist())\n",
    "print()\n",
    "print(\"# list of lists, stats first:\")\n",
    "pprint(ms.aslist(transpose=True))\n",
    "print()\n",
    "print(\"# list of dicts:\")\n",
    "pprint(ms.aslist(dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e93c31d",
   "metadata": {},
   "source": [
    "## Multiple statistics: dataframes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1212402b",
   "metadata": {},
   "source": [
    "`MultiNodeStat` objects can immediately be output as a Pandas dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "250d2808",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>degree</th>\n",
       "      <th>clustering</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>4.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   degree  clustering\n",
       "1       1    0.000000\n",
       "2       2    4.000000\n",
       "3       3    1.333333\n",
       "4       2    3.000000\n",
       "5       2    3.000000"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = H.nodes.multi([\"degree\", \"clustering\"]).aspandas()\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25357b7b",
   "metadata": {},
   "source": [
    "For example, it is now easy to get the per-degree average local clustering coefficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3c47eac0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>clustering</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>degree</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.333333</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        clustering\n",
       "degree            \n",
       "1         0.000000\n",
       "2         3.333333\n",
       "3         1.333333"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby(\"degree\").agg(\"mean\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23dd596a",
   "metadata": {},
   "source": [
    "One may also immediately plot any statistics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d28315b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "H.nodes.multi([\"degree\", \"clustering\"]).aspandas().plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977c336f",
   "metadata": {},
   "source": [
    "The `multi` method also accepts `NodeStat` objects, useful when passing arguments to each `NodeStat`, or when requesting attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a6c92003",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>degree</th>\n",
       "      <th>degree(order=3)</th>\n",
       "      <th>attrs(color)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>red</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>yellow</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>red</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   degree  degree(order=3) attrs(color)\n",
       "1       1                0          red\n",
       "2       2                1         blue\n",
       "3       3                1       yellow\n",
       "4       2                1          red\n",
       "5       2                1         blue"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.multi([\"degree\", H.nodes.degree(order=3), H.nodes.attrs(\"color\")]).aspandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e81027f",
   "metadata": {},
   "source": [
    "## Edge statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29d4aa9f",
   "metadata": {},
   "source": [
    "Every feature showcased above (lazy evaluation, type conversion, filtering, set operations, and multi objects) is supported for edge-quantity or edge-attribute mappings, via `EdgeStat` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3a43de55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "EdgeStat('order')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.edges.order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9e708cda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 2, 1: 3, 2: 2}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.edges.order.asdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "29154c7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "EdgeView((1,))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.edges.filterby(\"order\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "6b319bfc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>order</th>\n",
       "      <th>size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   order  size\n",
       "0      2     3\n",
       "1      3     4\n",
       "2      2     3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.edges.multi([\"order\", \"size\"]).aspandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82b3317f",
   "metadata": {},
   "source": [
    "## User-defined statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98b06d7d",
   "metadata": {},
   "source": [
    "Suppose during the course of your research you come up with a new node-level statistic. For the purpose of this tutorial, we are going to define a statistic called `user_degree`. The `user_degree` of a node is simply its standard degree times 10.\n",
    "\n",
    "Since this is also a node-quantity mapping, we would like to give it the same interface as `degree` and all the other `NodeStat`s. The stats package provides a simple way to do this. Simply use the `nodestat_func` decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fec60de5",
   "metadata": {},
   "outputs": [],
   "source": [
    "@xgi.nodestat_func\n",
    "def user_degree(net, bunch):\n",
    "    \"\"\"The user degree of a bunch of nodes in net.\"\"\"\n",
    "    return {n: 10 * net.degree(n) for n in bunch}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0be4a0d",
   "metadata": {},
   "source": [
    "Now `user_degree` is a valid stat that can be computed on any hypergraph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7409ae74",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 10, 2: 20, 3: 30, 4: 20, 5: 20}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.user_degree.asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65f4b7bf",
   "metadata": {},
   "source": [
    "Every single feature showcased above is available for use with `user_degree`, including filtering nodes and multi stats objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "314751dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView((2, 4, 5))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.filterby(\"user_degree\", 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7ae354dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>degree</th>\n",
       "      <th>user_degree</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   degree  user_degree\n",
       "1       1           10\n",
       "2       2           20\n",
       "3       3           30\n",
       "4       2           20\n",
       "5       2           20"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.nodes.multi([\"degree\", \"user_degree\"]).aspandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432346e6",
   "metadata": {},
   "source": [
    "The `@xgi.nodestat_func` decorator works on any function or callable that admits two parameters: `net` and `bunch`, where `net` is the network and `bunch` is an iterable of nodes in `net`. Additionally, the function must return a dictionary with pairs of the form `node: value`, where `node` is an element of `bunch`. The library will take care of type conversions, but the output value of this function must always be a dict."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60251fad",
   "metadata": {},
   "source": [
    "User-defined edge statistics can similarly be defined using the `@xgi.edgestat` decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4458166",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 ('venv': venv)",
   "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.10.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "78db47bee367e3fae825d59af43d695909ce208402094df58551906768c6e91c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}