algos/topologicalLinkPrediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9cfa203e-9881-473d-95a3-e9ab912ccd8d",
   "metadata": {},
   "source": [
    "# TigerGraph Data Science Library 101 - Topological Link Predication Algorithm\n",
    "This notebook shows the examples of using the most common topological link predication algorithms in TigerGraph Graph Science Library. More detailed explanations of these algorithms can be found in the official documentation (https://docs.tigergraph.com/graph-ml/current/link-prediction/).\n",
    "\n",
    "\n",
    "## Step1: Setting things up\n",
    "- Connect and Load data\n",
    "- Visualize the graph schema \n",
    "- Get basic stats, e.g., counts of nodes & edges"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b02309b4-cd57-4074-b849-6a09c6232e70",
   "metadata": {},
   "source": [
    "### Create connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2ead3778-60b5-4cc0-9d54-cc6c5209e4b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pandas as pd\n",
    "from pyTigerGraph import TigerGraphConnection\n",
    "\n",
    "# Read in DB configs\n",
    "with open('../config.json', \"r\") as config_file:\n",
    "    config = json.load(config_file)\n",
    "\n",
    "conn = TigerGraphConnection(\n",
    "    host=config[\"host\"],\n",
    "    username=config[\"username\"],\n",
    "    password=config[\"password\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93364e5a-ce51-4bfc-9c0c-492886eb8301",
   "metadata": {},
   "source": [
    "### Download movie dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "63e14e42-7360-438d-bd51-6cf3ef13295f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9be1d8f44ace40f49f118e30fbbfec66",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading:   0%|          | 0/1970 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pyTigerGraph.datasets import Datasets\n",
    "\n",
    "dataset_social = Datasets(\"social\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0ec49fe-56c5-473b-8439-a3c49ca6b05e",
   "metadata": {},
   "source": [
    "### Ingest data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b7060ef7-8098-4a1e-ac26-2db91626ad23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---- Checking database ----\n",
      "A graph with name social already exists in the database. Please drop it first before ingesting.\n"
     ]
    }
   ],
   "source": [
    "conn.ingestDataset(dataset_social, getToken=config[\"getToken\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5295a4ec-3e63-4f0f-a583-8fc23946f7fd",
   "metadata": {},
   "source": [
    "### Visualize schema"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "968c4c6d-4aa7-4c3b-8f89-6410d7a45e0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24c5f60c812141e7a7fe01fd5b3a9216",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "CytoscapeWidget(cytoscape_layout={'name': 'circle', 'animate': True, 'padding': 1}, cytoscape_style=[{'selecto…"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pyTigerGraph.visualization import drawSchema\n",
    "\n",
    "drawSchema(conn.getSchema(force=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0f0601e-31a4-4b19-8e89-3201b70cb021",
   "metadata": {},
   "source": [
    "### Print graph stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5fc11eec-57d8-4205-919c-376a9541d7aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node count: (Person : 12) \n",
      "Total node count:  12\n"
     ]
    }
   ],
   "source": [
    "vertices = conn.getVertexTypes()\n",
    "total_count = 0\n",
    "for vertex in vertices:\n",
    "    vertex_cnt = conn.getVertexCount(vertex)\n",
    "    total_count += vertex_cnt\n",
    "    print(\"Node count: ({} : {}) \".format(vertex, vertex_cnt))\n",
    "print(\"Total node count: \", total_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0bdbd7ef-a6f2-412d-b8fd-08d823c283c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Edges count: total  39\n",
      "{'Coworker': 11, 'Friend': 14, 'reverse_Friend': 14}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "edge_count = conn.getEdgeCount()\n",
    "print(\"Edges count: total \", sum(edge_count.values()))\n",
    "pprint.pprint(edge_count) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b56963ba-6914-4ced-8b13-204476ec1db5",
   "metadata": {},
   "source": [
    "## Step 2: Leveraging pyTigerGraph’s featurizer to run Topological Link Prediction algorithms\n",
    "\n",
    "pyTigerGraph provides a full suit of data science capabilities, and in this tutorial, we will showcase how to use featurizer to list out all available Topological Link Prediction algorithms in our GDS library, and to run a few popular algorithms as an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "53190137-12a4-4979-a2f7-569f4631e6b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "feat = conn.gds.featurizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "147af0c6-519c-4d31-97b7-76e1324f3e2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available algorithms for Topological Link Prediction:\n",
      "  adamic_adar:\n",
      "    01. name: tg_adamic_adar\n",
      "  common_neighbors:\n",
      "    02. name: tg_common_neighbors\n",
      "  preferential_attachment:\n",
      "    03. name: tg_preferential_attachment\n",
      "  resource_allocation:\n",
      "    04. name: tg_resource_allocation\n",
      "  same_community:\n",
      "    05. name: tg_same_community\n",
      "  total_neighbors:\n",
      "    06. name: tg_total_neighbors\n",
      "Call runAlgorithm() with the algorithm name to execute it\n"
     ]
    }
   ],
   "source": [
    "feat.listAlgorithms(\"Topological Link Prediction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62e3bcbf-d40f-4e6e-af4b-3f15f7bf97a2",
   "metadata": {},
   "source": [
    "## tg_adamic_adar\n",
    "\n",
    "The Adamic/Adar index is a measure according to the number of shared links between two vertices. It is defined as the sum of the inverse logarithmic degree centrality of the neighbors shared by the two vertices. This algorithm ignores edge weights. (https://docs.tigergraph.com/graph-ml/current/link-prediction/adamic-adar)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a06c9112-e7bd-4e2d-a959-2b9f095702ba",
   "metadata": {},
   "source": [
    "## Input Parameters\n",
    "\n",
    "* VERTEX v_source: The first vertex to compare {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* VERTEX v_target: The second vertex to compare with the first {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* SET<STRING> e_type_set: Edge types to traverse \n",
    "* BOOL print_results: if True, print result (True by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "aceadb2c-f554-4d97-a383-fbfc58541b60",
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    \"v_source\": {\"id\": \"Alex\", \"type\": \"Person\"},\n",
    "    \"v_target\": {\"id\": \"Bob\", \"type\": \"Person\"},\n",
    "    \"e_type_set\": [\"Coworker\"],\n",
    "    \"print_results\": True\n",
    "}\n",
    "\n",
    "results = feat.runAlgorithm(\"tg_adamic_adar\", params=params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb5deed4-bc9f-49f6-8e2b-328f4e9dace7",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "Returns Adamic Adar index between the two given vertices. If the two vertices do not have common neighbors, the algorithm will return a division by 0 error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7f56edcc-2579-43f5-b396-fe5141a5c583",
   "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>@@sum_closeness</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3.32193</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   @@sum_closeness\n",
       "0          3.32193"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_adamic_adar = pd.json_normalize(results)\n",
    "\n",
    "display(df_adamic_adar)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1083c852-223c-4c78-967f-9ce928a1f9d7",
   "metadata": {},
   "source": [
    "## tg_common_neighbors\n",
    "\n",
    "A vertex 𝐴 that is connected to vertices 𝐵 and 𝐶 is considered to be a \"common neighbor\" of 𝐵 and 𝐶. The common neighbors algorithm counts the number of common neighbors between two vertices. This algorithm ignores edge weights. (https://docs.tigergraph.com/graph-ml/current/link-prediction/common-neighbors)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fc11216-4137-474a-ba8a-e68821e1f2a6",
   "metadata": {},
   "source": [
    "## Input Parameters\n",
    "\n",
    "* VERTEX v_source: The first vertex to compare {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* VERTEX v_target: The second vertex to compare with the first {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* SET<STRING> e_type_set: Edge types to traverse \n",
    "* BOOL print_results: if True, print result (True by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6e6bc7b9-41b2-4992-b073-204c4be9413a",
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    \"v_source\": {\"id\": \"Alex\", \"type\": \"Person\"},\n",
    "    \"v_target\": {\"id\": \"Bob\", \"type\": \"Person\"},\n",
    "    \"e_type_set\": [\"Coworker\"],\n",
    "    \"print_results\": True\n",
    "}\n",
    "\n",
    "results = feat.runAlgorithm(\"tg_common_neighbors\", params=params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e695052-c939-4794-a86e-3e9176383ae4",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "Returns the number of common neighbors between two vertices expressed as a closeness value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8980aeaf-f344-4e0f-bc33-c8ab694091ca",
   "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>closeness</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   closeness\n",
       "0          1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_common_neighbors = pd.json_normalize(results)\n",
    "\n",
    "display(df_common_neighbors)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5d6b309-f77f-45e3-95d5-4b02fbece770",
   "metadata": {},
   "source": [
    "## tg_preferential_attachment\n",
    "\n",
    "Preferential Attachment is a measure to compute the closeness of vertices based on the number of their neighbors. The algorithm returns the product of the number of neighbors of the first vertex and the number of neighbors of the second vertex. (https://docs.tigergraph.com/graph-ml/current/link-prediction/preferential-attachment)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9c7e418-944c-45d2-af34-205cc5170610",
   "metadata": {},
   "source": [
    "## Input Parameters\n",
    "\n",
    "* VERTEX v_source: The first vertex to compare {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* VERTEX v_target: The second vertex to compare with the first {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* SET<STRING> e_type_set: Edge types to traverse\n",
    "* BOOL print_results: if True, print result (True by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "10fd47b7-c349-428f-b05c-8388603ffc10",
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    \"v_source\": {\"id\": \"Alex\", \"type\": \"Person\"},\n",
    "    \"v_target\": {\"id\": \"Bob\", \"type\": \"Person\"},\n",
    "    \"e_type_set\": [\"Coworker\"],\n",
    "    \"print_results\": True\n",
    "}\n",
    "\n",
    "results = feat.runAlgorithm(\"tg_preferential_attachment\", params=params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b602a173-348a-4cd9-908e-7c6c9582e315",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "The product of the number of neighbors of the two vertices. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4ee45c39-23d6-4000-80c4-d1c3886b733b",
   "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>closeness</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   closeness\n",
       "0          4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_preferential_attachment = pd.json_normalize(results)\n",
    "\n",
    "display(df_preferential_attachment)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "141081ef-af67-40f5-8aff-ea95d5f47372",
   "metadata": {},
   "source": [
    "## tg_resource_allocation\n",
    "\n",
    "Resource Allocation is used to compute the closeness of nodes based on their shared neighbors. (https://docs.tigergraph.com/graph-ml/current/link-prediction/resource-allocation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ea581a-297b-4ea7-859d-0dd4408fcd61",
   "metadata": {},
   "source": [
    "## Input Parameters\n",
    "\n",
    "* VERTEX v_source: The first vertex to compare {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* VERTEX v_target: The second vertex to compare with the first {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* SET<STRING> e_type_set: Edge types to traverse \n",
    "* BOOL print_results: if True, print result (True by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "76a2d7ab-bdb1-4850-94c0-ec0342806e5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    \"v_source\": {\"id\": \"Alex\", \"type\": \"Person\"},\n",
    "    \"v_target\": {\"id\": \"Bob\", \"type\": \"Person\"},\n",
    "    \"e_type_set\": [\"Coworker\"],\n",
    "    \"print_results\": True\n",
    "}\n",
    "\n",
    "results = feat.runAlgorithm(\"tg_resource_allocation\", params=params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67d9357d-dded-44c8-b459-bb5cbbd1292a",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "Returns a closeness value for two input vertices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "18ff8bc7-3e90-44bc-8427-06455b7bc6b5",
   "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>@@sum_closeness</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   @@sum_closeness\n",
       "0              0.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_resource_allocation = pd.json_normalize(results)\n",
    "\n",
    "display(df_resource_allocation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfafde54-447a-4afe-a2a6-1faae19b62cb",
   "metadata": {
    "tags": []
   },
   "source": [
    "## tg_total_neighbors\n",
    "\n",
    "The algorithm counts the total number of neighbors, or vertices connected by one hop, of two vertices. (https://docs.tigergraph.com/graph-ml/current/link-prediction/total-neighbors)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96003131-be56-443a-bbc1-6ce971a3ec51",
   "metadata": {},
   "source": [
    "## Input Parameters\n",
    "\n",
    "* VERTEX v_source: The first vertex to compare {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* VERTEX v_target: The second vertex to compare with the first {\"id\": \"vertex_id\", \"type\": \"vertex_type\"}\n",
    "* SET<STRING> e_type_set: Edge types to traverse \n",
    "* BOOL print_results: if True, print result (True by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "32ed10a2-3fcf-48bb-9f1d-6f28befbba96",
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    \"v_source\": {\"id\": \"Alex\", \"type\": \"Person\"},\n",
    "    \"v_target\": {\"id\": \"Bob\", \"type\": \"Person\"},\n",
    "    \"e_type_set\": [\"Coworker\"],\n",
    "    \"print_results\": True\n",
    "}\n",
    "\n",
    "results = feat.runAlgorithm(\"tg_total_neighbors\", params=params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13662066",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9281c0ae-ef03-4e5a-98d6-02802f6afbd2",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "The total number of neighbors of two vertices as a closeness value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "dc6e6c05-cc84-4bb3-b2ee-1cc65382d379",
   "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>closeness</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   closeness\n",
       "0          3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_total_neighbors = pd.json_normalize(results)\n",
    "\n",
    "display(df_total_neighbors)"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}