From 187a3286abfdf7eed4499ec810606ad8e7ddafcc Mon Sep 17 00:00:00 2001 From: Anthony Mahanna <43019056+aMahanna@users.noreply.github.com> Date: Fri, 31 Dec 2021 14:02:59 -0500 Subject: [PATCH] new: blog post preparation --- examples/ArangoDB_DGL_Adapter.ipynb | 285 ++-- .../outputs/ArangoDB_DGL_Adapter_output.ipynb | 1449 +++++++++++++++++ 2 files changed, 1612 insertions(+), 122 deletions(-) create mode 100644 examples/outputs/ArangoDB_DGL_Adapter_output.ipynb diff --git a/examples/ArangoDB_DGL_Adapter.ipynb b/examples/ArangoDB_DGL_Adapter.ipynb index 742b3e7..53eb7c5 100644 --- a/examples/ArangoDB_DGL_Adapter.ipynb +++ b/examples/ArangoDB_DGL_Adapter.ipynb @@ -34,7 +34,7 @@ "id": "bpvZS-1aeG89" }, "source": [ - "Version: 1.0.0\n", + "Version: 1.0.2\n", "\n", "Objective: Export Graphs from [ArangoDB](https://www.arangodb.com/), a multi-model Graph Database, to [Deep Graph Library](https://www.dgl.ai/) (DGL), a python package for graph neural networks, and vice-versa." ] @@ -58,10 +58,9 @@ "source": [ "%%capture\n", "!git clone -b oasis_connector --single-branch https://github.com/arangodb/interactive_tutorials.git\n", - "!git clone -b 1.0.1 --single-branch https://github.com/arangoml/dgl-adapter.git\n", - "!rsync -av dgl-adapter/examples/ ./ --exclude=.git\n", + "!git clone -b 1.0.2 --single-branch https://github.com/arangoml/dgl-adapter.git\n", "!rsync -av interactive_tutorials/ ./ --exclude=.git\n", - "!pip3 install adbdgl_adapter==1.0.1\n", + "!pip3 install adbdgl_adapter==1.0.2\n", "!pip3 install matplotlib\n", "!pip3 install pyArango\n", "!pip3 install networkx ## For drawing purposes " @@ -75,7 +74,7 @@ "base_uri": "https://localhost:8080/" }, "id": "RpqvL4COeG8-", - "outputId": "2df55e4e-03fa-47ed-c2c9-baf9f597e1d8" + "outputId": "4e453af8-33d9-4834-fb4e-250032695e01" }, "outputs": [], "source": [ @@ -129,7 +128,7 @@ "base_uri": "https://localhost:8080/" }, "id": "vf0350qvj8up", - "outputId": "a65f00d2-cd6e-4583-94d8-2c9884e2e2e2" + "outputId": "eadc8e26-4edd-4859-e074-88db180dab84" }, "outputs": [], "source": [ @@ -162,7 +161,7 @@ "base_uri": "https://localhost:8080/" }, "id": "oOS3AVAnkQEV", - "outputId": "4609cdef-25ce-4f00-94b5-482c76274f88" + "outputId": "96640c60-adfd-4785-98bb-26a38e40507b" }, "outputs": [], "source": [ @@ -198,7 +197,7 @@ "base_uri": "https://localhost:8080/" }, "id": "meLon-KgkU4h", - "outputId": "976680a4-eadd-43f2-da17-e6a574fad8a7" + "outputId": "c9bcbd68-9c41-4f65-eab9-83d2c8069d0a" }, "outputs": [], "source": [ @@ -236,7 +235,7 @@ "base_uri": "https://localhost:8080/" }, "id": "zTebQ0LOlsGA", - "outputId": "9c84cb84-f7ce-42b3-9174-01f38295c5dd" + "outputId": "3be2ec4d-bd08-4f11-b626-1312e931480b" }, "outputs": [], "source": [ @@ -279,7 +278,7 @@ "base_uri": "https://localhost:8080/" }, "id": "KsxNujb0mSqZ", - "outputId": "3f3fd2b1-e1d3-4b03-c6c4-43566672cbb5" + "outputId": "716e7226-dca0-42ae-e469-df5c975f852f" }, "outputs": [], "source": [ @@ -322,7 +321,7 @@ "base_uri": "https://localhost:8080/" }, "id": "2ekGwnJDeG8-", - "outputId": "92e9d288-0259-45cc-e73d-a8e9f629063a" + "outputId": "5cfdfdd4-ec46-4ec5-c69d-5864bb393077" }, "outputs": [], "source": [ @@ -330,16 +329,14 @@ "con = oasis.getTempCredentials()\n", "\n", "# Connect to the db via the python-arango driver\n", - "python_arango_db_driver = oasis.connect_python_arango(con)\n", + "db = oasis.connect_python_arango(con)\n", "\n", - "# (Alternative) Connect to the db via the pyArango driver\n", - "# pyarango_db_driver = oasis.connect(con)[con['dbName']]\n", - "\n", - "print()\n", + "print('\\n--------------------')\n", "print(\"https://{}:{}\".format(con[\"hostname\"], con[\"port\"]))\n", "print(\"Username: \" + con[\"username\"])\n", "print(\"Password: \" + con[\"password\"])\n", - "print(\"Database: \" + con[\"dbName\"])" + "print(\"Database: \" + con[\"dbName\"])\n", + "print('--------------------\\n')" ] }, { @@ -366,16 +363,7 @@ "id": "BM0iRYPDeG8_" }, "source": [ - "We will use an Fraud Detection example graph, explained in more detail in this [interactive notebook](https://colab.research.google.com/github/joerg84/Graph_Powered_ML_Workshop/blob/master/Fraud_Detection.ipynb)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1jWclaDdeG8_" - }, - "source": [ - "*Note the included arangorestore will only work on Linux system, if you want to run this notebook on a different OS please consider using the appropriate arangorestore from the [Download area](https://www.arangodb.com/download-major/).*" + "For demo purposes, we will be using the [ArangoDB Fraud Detection example graph](https://colab.research.google.com/github/joerg84/Graph_Powered_ML_Workshop/blob/master/Fraud_Detection.ipynb)." ] }, { @@ -388,76 +376,7 @@ "source": [ "%%capture\n", "!chmod -R 755 ./tools\n", - "!./tools/arangorestore -c none --server.endpoint http+ssl://{con[\"hostname\"]}:{con[\"port\"]} --server.username {con[\"username\"]} --server.database {con[\"dbName\"]} --server.password {con[\"password\"]} --replication-factor 3 --input-directory \"data/fraud_dump\"" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "227hLXnPeG8_" - }, - "source": [ - "# Create Graph" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "howeguvmeG8_" - }, - "source": [ - "The graph we will be using in the following looks as follows:" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "WqRlqnJCeG8_" - }, - "source": [ - "![networkX](https://github.com/arangoml/networkx-adapter/blob/master/examples/assets/fraud_graph.jpeg?raw=1) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "PybHP7jpeG8_", - "outputId": "ba3bfc7c-ef56-47e7-8e98-3763d4f34afe" - }, - "outputs": [], - "source": [ - "edge_definitions = [\n", - " {\n", - " \"edge_collection\": \"accountHolder\",\n", - " \"from_vertex_collections\": [\"customer\"],\n", - " \"to_vertex_collections\": [\"account\"],\n", - " },\n", - " {\n", - " \"edge_collection\": \"transaction\",\n", - " \"from_vertex_collections\": [\"account\"],\n", - " \"to_vertex_collections\": [\"account\"],\n", - " },\n", - "]\n", - "\n", - "name = \"fraud-detection\"\n", - "python_arango_db_driver.delete_graph(name, ignore_missing=True)\n", - "fraud_graph = python_arango_db_driver.create_graph(name, edge_definitions=edge_definitions)\n", - "\n", - "print(\"Graph Setup done.\")\n", - "print(fraud_graph)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ANrsn9GreG9A" - }, - "source": [ - "Feel free to visit the ArangoDB UI using the above link and login data and check the Graph!" + "!./tools/arangorestore -c none --server.endpoint http+ssl://{con[\"hostname\"]}:{con[\"port\"]} --server.username {con[\"username\"]} --server.database {con[\"dbName\"]} --server.password {con[\"password\"]} --replication-factor 3 --input-directory \"dgl-adapter/examples/data/fraud_dump\" --include-system-collections true" ] }, { @@ -466,7 +385,7 @@ "id": "QfE_tKxneG9A" }, "source": [ - "# Create Adapter" + "# Instantiate the Adapter" ] }, { @@ -475,7 +394,7 @@ "id": "kGfhzPT9eG9A" }, "source": [ - "Connect the ArangoDB_DGL_Adapter to our temp ArangoDB cluster:" + "Connect the ArangoDB-DGL Adapter to our temporary ArangoDB cluster:" ] }, { @@ -486,7 +405,7 @@ "base_uri": "https://localhost:8080/" }, "id": "oG496kBeeG9A", - "outputId": "50ecbdf5-c82f-4540-d345-14eb4a488f2c" + "outputId": "235419bb-52cc-429c-f497-b79b361689cc" }, "outputs": [], "source": [ @@ -512,6 +431,22 @@ "## Via ArangoDB Graph" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "H8nlvWCryPW0" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Graph\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_graph_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L182-L197)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case must point to an existing ArangoDB graph in your ArangoDB instance. " + ] + }, { "cell_type": "code", "execution_count": null, @@ -520,7 +455,7 @@ "base_uri": "https://localhost:8080/" }, "id": "zZ-Hu3lLVHgd", - "outputId": "39f32c51-0753-45a8-a361-dcf46d4e6148" + "outputId": "02940624-1b41-488f-99fa-d081a065e1b2" }, "outputs": [], "source": [ @@ -535,6 +470,7 @@ "# See more here: https://docs.python-arango.com/en/main/specs.html#arango.aql.AQL.execute\n", "\n", "# Show graph data\n", + "print('\\n--------------------')\n", "print(dgl_g)\n", "print(dgl_g.ntypes)\n", "print(dgl_g.etypes)" @@ -549,6 +485,23 @@ "## Via ArangoDB Collections" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "bRcCmqWGy1Kf" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Collections\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_collections_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L153-L180)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your DGL graph.\n", + "* The `vertex_collections` & `edge_collections` parameters must point to existing ArangoDB collections within your ArangoDB instance." + ] + }, { "cell_type": "code", "execution_count": null, @@ -557,7 +510,7 @@ "base_uri": "https://localhost:8080/" }, "id": "i4XOpdRLUNlJ", - "outputId": "b58e75d1-e935-4abd-9bdb-bc8935d9cdc8" + "outputId": "1cdd6aed-a084-4da8-b342-ee650efe0ccd" }, "outputs": [], "source": [ @@ -573,6 +526,7 @@ "# See more here: https://docs.python-arango.com/en/main/specs.html#arango.aql.AQL.execute\n", "\n", "# Show graph data\n", + "print('\\n--------------------')\n", "print(dgl_g)\n", "print(dgl_g.ntypes)\n", "print(dgl_g.etypes)" @@ -587,6 +541,23 @@ "## Via ArangoDB Metagraph" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "PipFzJ0HzTMA" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Collections\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L58-L151)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your DGL graph.\n", + "* The `metagraph` parameter should contain collections & associated document attributes names that exist within your ArangoDB instance." + ] + }, { "cell_type": "code", "execution_count": null, @@ -595,7 +566,7 @@ "base_uri": "https://localhost:8080/" }, "id": "7Kz8lXXq23Yk", - "outputId": "1458aef6-14e5-48c0-98bf-77f21431bc73" + "outputId": "2ce0cff8-a4a5-4373-8297-17e313a16aae" }, "outputs": [], "source": [ @@ -638,6 +609,25 @@ "## Via ArangoDB Metagraph with a custom controller" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "PGkGh_KjzlYM" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Collections\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L58-L151)\n", + "* [`adbdgl_adapter.controller._adb_attribute_to_dgl_feature()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L21-L47)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your DGL graph.\n", + "* The `metagraph` parameter should contain collections & associated document attributes names that exist within your ArangoDB instance.\n", + "* We are creating a custom `ADBDGL_Controller` to specify *how* to convert our ArangoDB vertex/edge attributes into DGL node/edge features. View the default `ADBDGL_Controller` [here](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L11)." + ] + }, { "cell_type": "code", "execution_count": null, @@ -646,7 +636,7 @@ "base_uri": "https://localhost:8080/" }, "id": "U4_vSdU_4AS4", - "outputId": "b719b0d4-c0a4-43a0-915f-8ee765e1ec86" + "outputId": "9d958954-ea94-4fa0-9778-255b2b02712e" }, "outputs": [], "source": [ @@ -764,16 +754,32 @@ "## Example 1: DGL Karate Graph" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "tx-tjPfx0U_h" + }, + "source": [ + "Data source\n", + "* [DGL Karate Graph](https://docs.dgl.ai/en/0.6.x/api/python/dgl.data.html#karate-club-dataset)\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.dgl_to_arangodb()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L199-L297)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your ArangoDB graph." + ] + }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 577 + "height": 0 }, "id": "eRVbiBy4ZdE4", - "outputId": "d44eb9d9-e046-443b-8ded-79654f004e02" + "outputId": "da33e345-87d7-442f-fbb7-5484b79889a5" }, "outputs": [], "source": [ @@ -783,7 +789,7 @@ "\n", "# Create the ArangoDB graph\n", "name = \"Karate\"\n", - "python_arango_db_driver.delete_graph(name, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(name, drop_collections=True, ignore_missing=True)\n", "adb_karate_graph = adbdgl_adapter.dgl_to_arangodb(name, dgl_karate_graph)\n", "\n", "print('\\n--------------------')\n", @@ -792,8 +798,8 @@ "print(\"Password: \" + con[\"password\"])\n", "print(\"Database: \" + con[\"dbName\"])\n", "print('--------------------\\n')\n", - "print(f\"\\nInspect the graph here: https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{name}\\n\")\n", - "print(f\"\\nView the original graph below:\")" + "print(f\"Inspect the graph here: https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{name}\\n\")\n", + "print(f\"View the original graph below:\")" ] }, { @@ -806,16 +812,32 @@ "## Example 2: DGL MiniGCDataset Graphs" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "KaExiE2x0-M6" + }, + "source": [ + "Data source\n", + "* [DGL Mini Graph Classification Dataset](https://docs.dgl.ai/en/0.6.x/api/python/dgl.data.html#mini-graph-classification-dataset)\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.dgl_to_arangodb()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L199-L297)\n", + "\n", + "Important notes\n", + "* The `name` parameters in this case are simply for naming your ArangoDB graph." + ] + }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 1000 + "height": 0 }, "id": "dADiexlAioGH", - "outputId": "273988c8-1749-4fe0-85fe-51b0e1ab2058" + "outputId": "f7926863-61bb-4202-ba7e-e55413d20ca5" }, "outputs": [], "source": [ @@ -837,9 +859,9 @@ "hypercube = \"Hypercube\"\n", "clique = \"Clique\"\n", "\n", - "python_arango_db_driver.delete_graph(lollipop, drop_collections=True, ignore_missing=True)\n", - "python_arango_db_driver.delete_graph(hypercube, drop_collections=True, ignore_missing=True)\n", - "python_arango_db_driver.delete_graph(clique, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(lollipop, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(hypercube, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(clique, drop_collections=True, ignore_missing=True)\n", "\n", "adb_lollipop_graph = adbdgl_adapter.dgl_to_arangodb(lollipop, dgl_lollipop_graph)\n", "adb_hypercube_graph = adbdgl_adapter.dgl_to_arangodb(hypercube, dgl_hypercube_graph)\n", @@ -868,6 +890,24 @@ "## Example 3: DGL MiniGCDataset Graphs with a custom controller" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "CZ1UX9YX1Zzo" + }, + "source": [ + "Data source\n", + "* [DGL Mini Graph Classification Dataset](https://docs.dgl.ai/en/0.6.x/api/python/dgl.data.html#mini-graph-classification-dataset)\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.dgl_to_arangodb()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L199-L297)\n", + "* [`adbdgl_adapter.controller._dgl_feature_to_adb_attribute()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L49-L70)\n", + "\n", + "Important notes\n", + "* The `name` parameters in this case are simply for naming your ArangoDB graph.\n", + "* We are creating a custom `ADBDGL_Controller` to specify *how* to convert our DGL node/edge features into ArangoDB vertex/edge attributes. View the default `ADBDGL_Controller` [here](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L11)." + ] + }, { "cell_type": "code", "execution_count": null, @@ -876,7 +916,7 @@ "base_uri": "https://localhost:8080/" }, "id": "jbJsvMMaoJoT", - "outputId": "2ddca41f-9c8b-4db4-c0aa-c1b2cc124fa5" + "outputId": "7cc01a20-201b-42ea-85e7-c60d0d8d2fbb" }, "outputs": [], "source": [ @@ -961,9 +1001,9 @@ "hypercube = \"Hypercube_With_Attributes\"\n", "clique = \"Clique_With_Attributes\"\n", "\n", - "python_arango_db_driver.delete_graph(lollipop, drop_collections=True, ignore_missing=True)\n", - "python_arango_db_driver.delete_graph(hypercube, drop_collections=True, ignore_missing=True)\n", - "python_arango_db_driver.delete_graph(clique, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(lollipop, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(hypercube, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(clique, drop_collections=True, ignore_missing=True)\n", "\n", "adb_lollipop_graph = adbdgl_adapter.dgl_to_arangodb(lollipop, dgl_lollipop_graph)\n", "adb_hypercube_graph = adbdgl_adapter.dgl_to_arangodb(hypercube, dgl_hypercube_graph)\n", @@ -986,15 +1026,16 @@ "colab": { "collapsed_sections": [ "ot1oJqn7m78n", - "7y81WHO8eG8_", - "227hLXnPeG8_", "QfE_tKxneG9A", "ZrEDmtqCVD0W", + "RQ4CknYfUEuz", "qEH6OdSB23Ya", + "DqIKT1lO4ASw", "UafSB_3JZNwK", - "gshTlSX_ZZsS" + "gshTlSX_ZZsS", + "CNj1xKhwoJoL" ], - "name": "ArangoDB_DGL_Adapter_v1.0.0.ipynb", + "name": "ArangoDB_DGL_Adapter_v1.ipynb", "provenance": [] }, "kernelspec": { diff --git a/examples/outputs/ArangoDB_DGL_Adapter_output.ipynb b/examples/outputs/ArangoDB_DGL_Adapter_output.ipynb new file mode 100644 index 0000000..b6ea068 --- /dev/null +++ b/examples/outputs/ArangoDB_DGL_Adapter_output.ipynb @@ -0,0 +1,1449 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "q8KesL7xeG89" + }, + "source": [ + "# ArangoDB DGL Adapter Getting Started Guide " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "U1d45V4OeG89" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nx9aa3LAeG89" + }, + "source": [ + "![arangodb](https://raw.githubusercontent.com/arangoml/dgl-adapter/master/examples/assets/adb_logo.png)\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bpvZS-1aeG89" + }, + "source": [ + "Version: 1.0.2\n", + "\n", + "Objective: Export Graphs from [ArangoDB](https://www.arangodb.com/), a multi-model Graph Database, to [Deep Graph Library](https://www.dgl.ai/) (DGL), a python package for graph neural networks, and vice-versa." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KS9c-vE5eG89" + }, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "fUnFAFAheG89" + }, + "outputs": [], + "source": [ + "%%capture\n", + "!git clone -b oasis_connector --single-branch https://github.com/arangodb/interactive_tutorials.git\n", + "!git clone -b 1.0.2 --single-branch https://github.com/arangoml/dgl-adapter.git\n", + "!rsync -av interactive_tutorials/ ./ --exclude=.git\n", + "!pip3 install adbdgl_adapter==1.0.2\n", + "!pip3 install matplotlib\n", + "!pip3 install pyArango\n", + "!pip3 install networkx ## For drawing purposes " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RpqvL4COeG8-", + "outputId": "4e453af8-33d9-4834-fb4e-250032695e01" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DGL backend not selected or invalid. Assuming PyTorch for now.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting the default backend to \"pytorch\". You can change it in the ~/.dgl/config.json file or export the DGLBACKEND environment variable. Valid options are: pytorch, mxnet, tensorflow (all lowercase)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using backend: pytorch\n" + ] + } + ], + "source": [ + "import json\n", + "import oasis\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import dgl\n", + "import torch\n", + "import networkx as nx\n", + "\n", + "from dgl import remove_self_loop\n", + "from dgl.data import KarateClubDataset\n", + "from dgl.data import MiniGCDataset\n", + "\n", + "from adbdgl_adapter.adapter import ADBDGL_Adapter\n", + "from adbdgl_adapter.controller import ADBDGL_Controller\n", + "from adbdgl_adapter.typings import Json, ArangoMetagraph, DGLCanonicalEType, DGLDataDict" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ot1oJqn7m78n" + }, + "source": [ + "# Understanding DGL" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N6Bx3hTjnGd7" + }, + "source": [ + "(referenced from [docs.dgl.ai](https://docs.dgl.ai/en/0.6.x/))\n", + "\n", + "\n", + "Deep Graph Library (DGL) is a Python package built for easy implementation of graph neural network model family, on top of existing DL frameworks (currently supporting **PyTorch**, **MXNet** and **TensorFlow**).\n", + "\n", + "DGL represents a directed graph as a `DGLGraph` object. You can construct a graph by specifying the number of nodes in the graph as well as the list of source and destination nodes. **Nodes in the graph have consecutive IDs starting from 0.**\n", + "\n", + "The following code constructs a directed \"star\" homogeneous graph with 6 nodes and 5 edges. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vf0350qvj8up", + "outputId": "eadc8e26-4edd-4859-e074-88db180dab84" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph(num_nodes=6, num_edges=5,\n", + " ndata_schemes={}\n", + " edata_schemes={})\n", + "\n", + "Canonical Edge Types: [('_N', '_E', '_N')]\n" + ] + } + ], + "source": [ + "# A homogeneous graph with 6 nodes, and 5 edges\n", + "g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]))\n", + "print(g)\n", + "\n", + "# Print the graph's canonical edge types\n", + "print(\"\\nCanonical Edge Types: \", g.canonical_etypes)\n", + "# [('_N', '_E', '_N')]\n", + "# '_N' being the only Node type\n", + "# '_E' being the only Edge type" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wvJ0506mkMjz" + }, + "source": [ + "\n", + "In DGL, a heterogeneous graph (heterograph for short) is specified with a series of graphs as below, one per relation. Each relation is a string triplet `(source node type, edge type, destination node type)`. Since relations disambiguate the edge types, DGL calls them canonical edge types:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oOS3AVAnkQEV", + "outputId": "96640c60-adfd-4785-98bb-26a38e40507b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph(num_nodes={'game': 4, 'user': 4},\n", + " num_edges={('user', 'follows', 'game'): 3, ('user', 'follows', 'user'): 2, ('user', 'plays', 'game'): 2},\n", + " metagraph=[('user', 'game', 'follows'), ('user', 'game', 'plays'), ('user', 'user', 'follows')])\n", + "\n", + "Canonical Edge Types: [('user', 'follows', 'game'), ('user', 'follows', 'user'), ('user', 'plays', 'game')]\n", + "\n", + "Node Types: ['game', 'user']\n", + "\n", + "Edge Types: ['follows', 'follows', 'plays']\n" + ] + } + ], + "source": [ + "# A heterogeneous graph with 8 nodes, and 7 edges\n", + "g = dgl.heterograph({\n", + " ('user', 'follows', 'user'): (torch.tensor([0, 1]), torch.tensor([1, 2])),\n", + " ('user', 'follows', 'game'): (torch.tensor([0, 1, 2]), torch.tensor([1, 2, 3])),\n", + " ('user', 'plays', 'game'): (torch.tensor([1, 3]), torch.tensor([2, 3]))\n", + "})\n", + "\n", + "print(g)\n", + "print(\"\\nCanonical Edge Types: \", g.canonical_etypes)\n", + "print(\"\\nNode Types: \", g.ntypes)\n", + "print(\"\\nEdge Types: \", g.etypes)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5C-R0tkkkS5N" + }, + "source": [ + "Many graph data contain attributes on nodes and edges. Although the types of node and edge attributes can be arbitrary in real world, **DGLGraph only accepts attributes stored in tensors** (with numerical contents). Consequently, an attribute of all the nodes or edges must have the same shape. In the context of deep learning, those attributes are often called features.\n", + "\n", + "You can assign and retrieve node and edge features via ndata and edata interface." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "meLon-KgkU4h", + "outputId": "c9bcbd68-9c41-4f65-eab9-83d2c8069d0a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph(num_nodes=6, num_edges=5,\n", + " ndata_schemes={'x': Scheme(shape=(), dtype=torch.int64)}\n", + " edata_schemes={'a': Scheme(shape=(4,), dtype=torch.float32)})\n", + "\n", + "Node Data X attribute: tensor([151, 124, 41, 89, 76, 55])\n", + "\n", + "Edge Data A attribute: tensor([[-0.9712, 0.3131, -1.7787, -0.4953],\n", + " [ 1.5366, -0.8591, -1.4719, 0.5857],\n", + " [-0.5803, 0.6757, 0.9276, -0.9756],\n", + " [ 0.4396, 1.0612, 0.0943, 0.6856],\n", + " [-0.8685, -1.3693, -0.1184, -1.0903]])\n" + ] + } + ], + "source": [ + "# A homogeneous graph with 6 nodes, and 5 edges\n", + "g = dgl.graph(([0, 0, 0, 0, 0], [1, 2, 3, 4, 5]))\n", + "\n", + "# Assign an integer value for each node.\n", + "g.ndata['x'] = torch.tensor([151, 124, 41, 89, 76, 55])\n", + "# Assign a 4-dimensional edge feature vector for each edge.\n", + "g.edata['a'] = torch.randn(5, 4)\n", + "\n", + "print(g)\n", + "print(\"\\nNode Data X attribute: \", g.ndata['x'])\n", + "print(\"\\nEdge Data A attribute: \", g.edata['a'])\n", + "\n", + "\n", + "# NOTE: The following line ndata insertion will fail, since not all nodes have been assigned an attribute value\n", + "# g.ndata['bad_attribute'] = torch.tensor([0,10,20,30,40])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ETRCZzF1lSLE" + }, + "source": [ + "When multiple node/edge types are introduced, users need to specify the particular node/edge type when invoking a DGLGraph API for type-specific information. In addition, nodes/edges of different types have separate IDs." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zTebQ0LOlsGA", + "outputId": "3be2ec4d-bd08-4f11-b626-1312e931480b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All nodes: 8\n", + "User nodes: 4\n", + "tensor([0, 1, 2, 3])\n" + ] + } + ], + "source": [ + "g = dgl.heterograph({\n", + " ('user', 'follows', 'user'): (torch.tensor([0, 1]), torch.tensor([1, 2])),\n", + " ('user', 'follows', 'game'): (torch.tensor([0, 1, 2]), torch.tensor([1, 2, 3])),\n", + " ('user', 'plays', 'game'): (torch.tensor([1, 3]), torch.tensor([2, 3]))\n", + "})\n", + "\n", + "# Get the number of all nodes in the graph\n", + "print(\"All nodes: \", g.num_nodes())\n", + "\n", + "# Get the number of user nodes\n", + "print(\"User nodes: \", g.num_nodes('user'))\n", + "\n", + "# Nodes of different types have separate IDs,\n", + "# hence not well-defined without a type specified\n", + "# print(g.nodes())\n", + "#DGLError: Node type name must be specified if there are more than one node types.\n", + "\n", + "print(g.nodes('user'))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H9dwJuKvmK0w" + }, + "source": [ + "To set/get features for a specific node/edge type, DGL provides two new types of syntax – g.nodes[‘node_type’].data[‘feat_name’] and g.edges[‘edge_type’].data[‘feat_name’].\n", + "\n", + "**Note:** If the graph only has one node/edge type, there is no need to specify the node/edge type." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KsxNujb0mSqZ", + "outputId": "716e7226-dca0-42ae-e469-df5c975f852f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "defaultdict(, {'age': {'user': tensor([21, 16, 38, 64])}})\n" + ] + } + ], + "source": [ + "g = dgl.heterograph({\n", + " ('user', 'follows', 'user'): (torch.tensor([0, 1]), torch.tensor([1, 2])),\n", + " ('user', 'follows', 'game'): (torch.tensor([0, 1, 2]), torch.tensor([1, 2, 3])),\n", + " ('user', 'plays', 'game'): (torch.tensor([1, 3]), torch.tensor([2, 3]))\n", + "})\n", + "\n", + "g.nodes['user'].data['age'] = torch.tensor([21, 16, 38, 64])\n", + "# An alternative (yet equivalent) syntax:\n", + "# g.ndata['age'] = {'user': torch.tensor([21, 16, 38, 64])}\n", + "\n", + "print(g.ndata)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1M_isKWLnCfr" + }, + "source": [ + "For more info, visit https://docs.dgl.ai/en/0.6.x/. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Oc__NAd1eG8-" + }, + "source": [ + "# Create a Temporary ArangoDB Instance" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2ekGwnJDeG8-", + "outputId": "5cfdfdd4-ec46-4ec5-c69d-5864bb393077" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requesting new temp credentials.\n", + "Temp database ready to use.\n", + "\n", + "--------------------\n", + "https://tutorials.arangodb.cloud:8529\n", + "Username: TUT487i8kal98gb73c2iklds\n", + "Password: TUTn5t85w8t50kcupmo2mmyb\n", + "Database: TUTn187e39v9qho3768ilyk4\n", + "--------------------\n", + "\n" + ] + } + ], + "source": [ + "# Request temporary instance from the managed ArangoDB Cloud Oasis.\n", + "con = oasis.getTempCredentials()\n", + "\n", + "# Connect to the db via the python-arango driver\n", + "db = oasis.connect_python_arango(con)\n", + "\n", + "print('\\n--------------------')\n", + "print(\"https://{}:{}\".format(con[\"hostname\"], con[\"port\"]))\n", + "print(\"Username: \" + con[\"username\"])\n", + "print(\"Password: \" + con[\"password\"])\n", + "print(\"Database: \" + con[\"dbName\"])\n", + "print('--------------------\\n')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e4QfL37neG8_" + }, + "source": [ + "Feel free to use to above URL to checkout the UI!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7y81WHO8eG8_" + }, + "source": [ + "# Data Import" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BM0iRYPDeG8_" + }, + "source": [ + "For demo purposes, we will be using the [ArangoDB Fraud Detection example graph](https://colab.research.google.com/github/joerg84/Graph_Powered_ML_Workshop/blob/master/Fraud_Detection.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "7bgGJ3QkeG8_" + }, + "outputs": [], + "source": [ + "%%capture\n", + "!chmod -R 755 ./tools\n", + "!./tools/arangorestore -c none --server.endpoint http+ssl://{con[\"hostname\"]}:{con[\"port\"]} --server.username {con[\"username\"]} --server.database {con[\"dbName\"]} --server.password {con[\"password\"]} --replication-factor 3 --input-directory \"dgl-adapter/examples/data/fraud_dump\" --include-system-collections true" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QfE_tKxneG9A" + }, + "source": [ + "# Instantiate the Adapter" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kGfhzPT9eG9A" + }, + "source": [ + "Connect the ArangoDB-DGL Adapter to our temporary ArangoDB cluster:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oG496kBeeG9A", + "outputId": "235419bb-52cc-429c-f497-b79b361689cc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connecting to https://tutorials.arangodb.cloud:8529\n" + ] + } + ], + "source": [ + "adbdgl_adapter = ADBDGL_Adapter(con)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uByvwf9feG9A" + }, + "source": [ + "# ArangoDB to DGL\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZrEDmtqCVD0W" + }, + "source": [ + "## Via ArangoDB Graph" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H8nlvWCryPW0" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Graph\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_graph_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L182-L197)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case must point to an existing ArangoDB graph in your ArangoDB instance. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zZ-Hu3lLVHgd", + "outputId": "02940624-1b41-488f-99fa-d081a065e1b2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DGL: fraud-detection created\n", + "\n", + "--------------------\n", + "Graph(num_nodes={'account': 54, 'customer': 17},\n", + " num_edges={('account', 'accountHolder', 'customer'): 54, ('account', 'transaction', 'account'): 62},\n", + " metagraph=[('account', 'customer', 'accountHolder'), ('account', 'account', 'transaction')])\n", + "['account', 'customer']\n", + "['accountHolder', 'transaction']\n" + ] + } + ], + "source": [ + "# Define graph name\n", + "graph_name = \"fraud-detection\"\n", + "\n", + "# Create DGL graph from ArangoDB graph\n", + "dgl_g = adbdgl_adapter.arangodb_graph_to_dgl(graph_name)\n", + "\n", + "# You can also provide valid Python-Arango AQL query options to the command above, like such:\n", + "# dgl_g = aadbdgl_adapter.arangodb_graph_to_dgl(graph_name, ttl=1000, stream=True)\n", + "# See more here: https://docs.python-arango.com/en/main/specs.html#arango.aql.AQL.execute\n", + "\n", + "# Show graph data\n", + "print('\\n--------------------')\n", + "print(dgl_g)\n", + "print(dgl_g.ntypes)\n", + "print(dgl_g.etypes)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RQ4CknYfUEuz" + }, + "source": [ + "## Via ArangoDB Collections" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bRcCmqWGy1Kf" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Collections\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_collections_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L153-L180)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your DGL graph.\n", + "* The `vertex_collections` & `edge_collections` parameters must point to existing ArangoDB collections within your ArangoDB instance." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "i4XOpdRLUNlJ", + "outputId": "1cdd6aed-a084-4da8-b342-ee650efe0ccd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DGL: fraud-detection created\n", + "\n", + "--------------------\n", + "Graph(num_nodes={'Class': 4, 'account': 54, 'customer': 17},\n", + " num_edges={('Class', 'Relationship', 'Class'): 4, ('account', 'accountHolder', 'customer'): 54, ('account', 'transaction', 'account'): 62},\n", + " metagraph=[('Class', 'Class', 'Relationship'), ('account', 'customer', 'accountHolder'), ('account', 'account', 'transaction')])\n", + "['Class', 'account', 'customer']\n", + "['Relationship', 'accountHolder', 'transaction']\n" + ] + } + ], + "source": [ + "# Define collection\n", + "vertex_collections = {\"account\", \"Class\", \"customer\"}\n", + "edge_collections = {\"accountHolder\", \"Relationship\", \"transaction\"}\n", + "\n", + "# Create DGL from ArangoDB collections\n", + "dgl_g = adbdgl_adapter.arangodb_collections_to_dgl(\"fraud-detection\", vertex_collections, edge_collections)\n", + "\n", + "# You can also provide valid Python-Arango AQL query options to the command above, like such:\n", + "# dgl_g = adbdgl_adapter.arangodb_collections_to_dgl(\"fraud-detection\", vertex_collections, edge_collections, ttl=1000, stream=True)\n", + "# See more here: https://docs.python-arango.com/en/main/specs.html#arango.aql.AQL.execute\n", + "\n", + "# Show graph data\n", + "print('\\n--------------------')\n", + "print(dgl_g)\n", + "print(dgl_g.ntypes)\n", + "print(dgl_g.etypes)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qEH6OdSB23Ya" + }, + "source": [ + "## Via ArangoDB Metagraph" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PipFzJ0HzTMA" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Collections\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L58-L151)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your DGL graph.\n", + "* The `metagraph` parameter should contain collections & associated document attributes names that exist within your ArangoDB instance." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7Kz8lXXq23Yk", + "outputId": "2ce0cff8-a4a5-4373-8297-17e313a16aae" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DGL: FraudDetection created\n", + "\n", + "--------------\n", + "Graph(num_nodes={'Class': 4, 'account': 54, 'customer': 17},\n", + " num_edges={('Class', 'Relationship', 'Class'): 4, ('account', 'accountHolder', 'customer'): 54, ('account', 'transaction', 'account'): 62},\n", + " metagraph=[('Class', 'Class', 'Relationship'), ('account', 'customer', 'accountHolder'), ('account', 'account', 'transaction')])\n", + "\n", + "--------------\n", + "defaultdict(, {'concrete': {'Class': tensor([True, True, True, True])}, 'Balance': {'account': tensor([5331, 7630, 1433, 2201, 4837, 5817, 1689, 1042, 4104, 10, 2338, 10,\n", + " 3779, 0, 529, 0, 1992, 2912, 6367, 1819, 0, 221, 5062, 2372,\n", + " 841, 5393, 1138, 8414, 4064, 5686, 6294, 6540, 7358, 3452, 0, 3993,\n", + " 10, 0, 471, 8148, 5832, 1758, 1747, 1679, 6789, 1599, 8320, 0,\n", + " 10, 8626, 7199, 8644, 3879, 10])}, 'customer_id': {'account': tensor([10000009, 10000004, 10000004, 10000010, 10000002, 10000011, 10000015,\n", + " 10000006, 10000010, 10810, 10000002, 10000014, 10000008, 0,\n", + " 10000002, 0, 10000008, 10000006, 10000012, 10000015, 10000001,\n", + " 10000010, 10000015, 10000005, 10000009, 10000008, 10000011, 10000014,\n", + " 10000010, 10000006, 10000002, 10000007, 10000006, 10000005, 0,\n", + " 10000010, 10810, 0, 10000009, 10000006, 10000002, 10000005,\n", + " 10000009, 10000012, 10000007, 10000002, 10000014, 0, 10810,\n", + " 10000016, 10000006, 10000016, 10000013, 10810])}, 'rank': {'account': tensor([0.0021, 0.0031, 0.0052, 0.0021, 0.0046, 0.0037, 0.0032, 0.0042, 0.0021,\n", + " 0.0021, 0.0030, 0.0037, 0.0040, 0.0037, 0.0021, 0.0046, 0.0040, 0.0030,\n", + " 0.0026, 0.0032, 0.0021, 0.0034, 0.0032, 0.0021, 0.0021, 0.0035, 0.0026,\n", + " 0.0026, 0.0046, 0.0021, 0.0021, 0.0035, 0.0036, 0.0036, 0.0038, 0.0055,\n", + " 0.0021, 0.0041, 0.0044, 0.0021, 0.0030, 0.0035, 0.0033, 0.0026, 0.0071,\n", + " 0.0036, 0.0032, 0.0059, 0.0021, 0.0090, 0.0057, 0.0032, 0.0026, 0.0021]), 'customer': tensor([0.0135, 0.0050, 0.0062, 0.0066, 0.0096, 0.0088, 0.0089, 0.0047, 0.0066,\n", + " 0.0045, 0.0062, 0.0103, 0.0081, 0.0039, 0.0054, 0.0044, 0.0093])}})\n", + "--------------\n", + "\n", + "defaultdict(, {'sender_bank_id': {('account', 'transaction', 'account'): tensor([10000000003, 10000000002, 10000000001, 10000000001, 10000000002,\n", + " 10000000003, 10000000003, 10000000002, 10000000002, 10000000003,\n", + " 10000000001, 10000000001, 0, 10000000003, 10000000003,\n", + " 0, 10000000002, 0, 10000000001, 10000000003,\n", + " 10000000001, 10000000003, 10000000002, 0, 10000000003,\n", + " 10000000003, 10000000003, 10000000003, 10000000001, 10000000001,\n", + " 10000000002, 10000000001, 10000000003, 10000000003, 10000000001,\n", + " 10000000001, 0, 10000000003, 10000000002, 10000000001,\n", + " 10000000002, 10000000003, 10000000003, 10000000003, 10000000002,\n", + " 10000000003, 10000000002, 10000000003, 10000000002, 10000000001,\n", + " 10000000001, 0, 10000000003, 10000000003, 0,\n", + " 10000000003, 10000000003, 10000000001, 10000000001, 10000000003,\n", + " 10000000003, 10000000002])}, 'receiver_bank_id': {('account', 'transaction', 'account'): tensor([10000000003, 10000000003, 10000000001, 10000000002, 10000000002,\n", + " 10000000003, 10000000001, 10000000003, 10000000001, 10000000003,\n", + " 10000000002, 10000000003, 0, 10000000003, 10000000003,\n", + " 0, 10000000001, 0, 10000000002, 10000000003,\n", + " 10000000003, 10000000003, 10000000001, 0, 10000000003,\n", + " 10000000002, 10000000003, 10000000003, 10000000001, 10000000001,\n", + " 10000000003, 10000000003, 10000000003, 10000000003, 10000000001,\n", + " 10000000002, 0, 10000000001, 10000000001, 10000000002,\n", + " 10000000001, 10000000003, 10000000003, 10000000003, 10000000001,\n", + " 10000000003, 10000000002, 10000000003, 10000000002, 10000000001,\n", + " 10000000003, 0, 10000000003, 10000000003, 0,\n", + " 10000000003, 10000000002, 10000000002, 10000000001, 10000000003,\n", + " 10000000003, 10000000003])}, 'transaction_amt': {('account', 'transaction', 'account'): tensor([9000, 299, 498, 954, 756, 627, 142, 946, 920, 9000, 421, 343,\n", + " 9000, 457, 9000, 9000, 53, 9000, 284, 120, 441, 9000, 364, 901,\n", + " 9000, 279, 9000, 9000, 273, 127, 952, 354, 795, 9000, 835, 761,\n", + " 9000, 478, 172, 804, 665, 995, 9000, 9000, 670, 9000, 340, 9000,\n", + " 747, 347, 52, 911, 762, 9000, 0, 790, 619, 491, 954, 9000,\n", + " 9000, 843])}})\n" + ] + } + ], + "source": [ + "# Define Metagraph\n", + "fraud_detection_metagraph = {\n", + " \"vertexCollections\": {\n", + " \"account\": {\"rank\", \"Balance\", \"customer_id\"},\n", + " \"Class\": {\"concrete\"},\n", + " \"customer\": {\"rank\"},\n", + " },\n", + " \"edgeCollections\": {\n", + " \"accountHolder\": {},\n", + " \"Relationship\": {},\n", + " \"transaction\": {\"receiver_bank_id\", \"sender_bank_id\", \"transaction_amt\"},\n", + " },\n", + "}\n", + "\n", + "# Create DGL Graph from attributes\n", + "dgl_g = adbdgl_adapter.arangodb_to_dgl('FraudDetection', fraud_detection_metagraph)\n", + "\n", + "# You can also provide valid Python-Arango AQL query options to the command above, like such:\n", + "# dgl_g = adbdgl_adapter.arangodb_to_dgl(graph_name = 'FraudDetection', fraud_detection_metagraph, ttl=1000, stream=True)\n", + "# See more here: https://docs.python-arango.com/en/main/specs.html#arango.aql.AQL.execute\n", + "\n", + "# Show graph data\n", + "print('\\n--------------')\n", + "print(dgl_g)\n", + "print('\\n--------------')\n", + "print(dgl_g.ndata)\n", + "print('--------------\\n')\n", + "print(dgl_g.edata)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DqIKT1lO4ASw" + }, + "source": [ + "## Via ArangoDB Metagraph with a custom controller" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PGkGh_KjzlYM" + }, + "source": [ + "Data source\n", + "* ArangoDB Fraud-Detection Collections\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.arangodb_to_dgl()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L58-L151)\n", + "* [`adbdgl_adapter.controller._adb_attribute_to_dgl_feature()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L21-L47)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your DGL graph.\n", + "* The `metagraph` parameter should contain collections & associated document attributes names that exist within your ArangoDB instance.\n", + "* We are creating a custom `ADBDGL_Controller` to specify *how* to convert our ArangoDB vertex/edge attributes into DGL node/edge features. View the default `ADBDGL_Controller` [here](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L11)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "U4_vSdU_4AS4", + "outputId": "9d958954-ea94-4fa0-9778-255b2b02712e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connecting to https://tutorials.arangodb.cloud:8529\n", + "DGL: FraudDetection created\n", + "\n", + "--------------\n", + "Graph(num_nodes={'Class': 4, 'account': 54, 'customer': 17},\n", + " num_edges={('Class', 'Relationship', 'Class'): 4, ('account', 'accountHolder', 'customer'): 54, ('account', 'transaction', 'account'): 62},\n", + " metagraph=[('Class', 'Class', 'Relationship'), ('account', 'customer', 'accountHolder'), ('account', 'account', 'transaction')])\n", + "\n", + "--------------\n", + "defaultdict(, {'concrete': {'Class': tensor([True, True, True, True])}, 'name': {'Class': tensor([0, 1, 2, 3])}, 'rank': {'account': tensor([0.0021, 0.0031, 0.0052, 0.0021, 0.0046, 0.0037, 0.0032, 0.0042, 0.0021,\n", + " 0.0021, 0.0030, 0.0037, 0.0040, 0.0037, 0.0021, 0.0046, 0.0040, 0.0030,\n", + " 0.0026, 0.0032, 0.0021, 0.0034, 0.0032, 0.0021, 0.0021, 0.0035, 0.0026,\n", + " 0.0026, 0.0046, 0.0021, 0.0021, 0.0035, 0.0036, 0.0036, 0.0038, 0.0055,\n", + " 0.0021, 0.0041, 0.0044, 0.0021, 0.0030, 0.0035, 0.0033, 0.0026, 0.0071,\n", + " 0.0036, 0.0032, 0.0059, 0.0021, 0.0090, 0.0057, 0.0032, 0.0026, 0.0021]), 'customer': tensor([0.0135, 0.0050, 0.0062, 0.0066, 0.0096, 0.0088, 0.0089, 0.0047, 0.0066,\n", + " 0.0045, 0.0062, 0.0103, 0.0081, 0.0039, 0.0054, 0.0044, 0.0093])}, 'Ssn': {'customer': tensor([123456786, 123456780, 123456780, 123456787, 123456780, 123456789,\n", + " 123456780, 123456785, 123456783, 123456784, 123456780, 123456788,\n", + " 123456782, 123456781, 123456780, 123456780, 111223333])}, 'Sex': {'customer': tensor([1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1])}})\n", + "--------------\n", + "\n", + "defaultdict(, {'sender_bank_id': {('account', 'transaction', 'account'): tensor([10000000003, 10000000002, 10000000001, 10000000001, 10000000002,\n", + " 10000000003, 10000000003, 10000000002, 10000000002, 10000000003,\n", + " 10000000001, 10000000001, 0, 10000000003, 10000000003,\n", + " 0, 10000000002, 0, 10000000001, 10000000003,\n", + " 10000000001, 10000000003, 10000000002, 0, 10000000003,\n", + " 10000000003, 10000000003, 10000000003, 10000000001, 10000000001,\n", + " 10000000002, 10000000001, 10000000003, 10000000003, 10000000001,\n", + " 10000000001, 0, 10000000003, 10000000002, 10000000001,\n", + " 10000000002, 10000000003, 10000000003, 10000000003, 10000000002,\n", + " 10000000003, 10000000002, 10000000003, 10000000002, 10000000001,\n", + " 10000000001, 0, 10000000003, 10000000003, 0,\n", + " 10000000003, 10000000003, 10000000001, 10000000001, 10000000003,\n", + " 10000000003, 10000000002])}, 'receiver_bank_id': {('account', 'transaction', 'account'): tensor([10000000003, 10000000003, 10000000001, 10000000002, 10000000002,\n", + " 10000000003, 10000000001, 10000000003, 10000000001, 10000000003,\n", + " 10000000002, 10000000003, 0, 10000000003, 10000000003,\n", + " 0, 10000000001, 0, 10000000002, 10000000003,\n", + " 10000000003, 10000000003, 10000000001, 0, 10000000003,\n", + " 10000000002, 10000000003, 10000000003, 10000000001, 10000000001,\n", + " 10000000003, 10000000003, 10000000003, 10000000003, 10000000001,\n", + " 10000000002, 0, 10000000001, 10000000001, 10000000002,\n", + " 10000000001, 10000000003, 10000000003, 10000000003, 10000000001,\n", + " 10000000003, 10000000002, 10000000003, 10000000002, 10000000001,\n", + " 10000000003, 0, 10000000003, 10000000003, 0,\n", + " 10000000003, 10000000002, 10000000002, 10000000001, 10000000003,\n", + " 10000000003, 10000000003])}, 'transaction_date': {('account', 'transaction', 'account'): tensor([ 201966, 201721, 2017528, 2018924, 2017516, 2018128, 2019213,\n", + " 201847, 2017914, 201966, 2017810, 20181020, 0, 2017724,\n", + " 201966, 0, 2019311, 0, 2018211, 2018125, 201932,\n", + " 201966, 201795, 0, 201966, 2017111, 201966, 201966,\n", + " 2019822, 2017317, 2019124, 2017121, 2017110, 201966, 2017717,\n", + " 20181012, 0, 20181023, 2019724, 2019611, 2019928, 2019117,\n", + " 201966, 201966, 2017328, 201966, 2019316, 201966, 2017914,\n", + " 2017521, 201713, 0, 2018124, 201966, 0, 201784,\n", + " 201713, 20171212, 2019413, 201966, 201966, 201887])}, 'trans_time': {('account', 'transaction', 'account'): tensor([1136, 1516, 1340, 1030, 1552, 1116, 1450, 924, 1046, 1426, 1247, 1459,\n", + " 0, 1459, 1258, 0, 1758, 0, 1230, 1210, 1252, 1039, 1741, 0,\n", + " 1420, 1713, 1710, 1028, 1636, 1054, 1658, 1332, 1316, 955, 1629, 1642,\n", + " 0, 1710, 932, 1652, 1018, 1527, 1555, 1640, 1158, 1035, 1015, 1133,\n", + " 1320, 1514, 1213, 0, 1133, 1340, 0, 1026, 1312, 1027, 1745, 1342,\n", + " 1520, 1141])}, 'transaction_amt': {('account', 'transaction', 'account'): tensor([9000, 299, 498, 954, 756, 627, 142, 946, 920, 9000, 421, 343,\n", + " 9000, 457, 9000, 9000, 53, 9000, 284, 120, 441, 9000, 364, 901,\n", + " 9000, 279, 9000, 9000, 273, 127, 952, 354, 795, 9000, 835, 761,\n", + " 9000, 478, 172, 804, 665, 995, 9000, 9000, 670, 9000, 340, 9000,\n", + " 747, 347, 52, 911, 762, 9000, 0, 790, 619, 491, 954, 9000,\n", + " 9000, 843])}})\n" + ] + } + ], + "source": [ + "# Define Metagraph\n", + "fraud_detection_metagraph = {\n", + " \"vertexCollections\": {\n", + " \"account\": {\"rank\"},\n", + " \"Class\": {\"concrete\", \"name\"},\n", + " \"customer\": {\"Sex\", \"Ssn\", \"rank\"},\n", + " },\n", + " \"edgeCollections\": {\n", + " \"accountHolder\": {},\n", + " \"Relationship\": {},\n", + " \"transaction\": {\"receiver_bank_id\", \"sender_bank_id\", \"transaction_amt\", \"transaction_date\", \"trans_time\"},\n", + " },\n", + "}\n", + "\n", + "# When converting to DGL via an ArangoDB Metagraph that contains non-numerical values, a user-defined \n", + "# Controller class is required to specify how ArangoDB attributes should be converted to DGL features.\n", + "class FraudDetection_ADBDGL_Controller(ADBDGL_Controller):\n", + " \"\"\"ArangoDB-DGL controller.\n", + "\n", + " Responsible for controlling how ArangoDB attributes\n", + " are converted into DGL features, and vice-versa.\n", + "\n", + " You can derive your own custom ADBDGL_Controller if you want to maintain\n", + " consistency between your ArangoDB attributes & your DGL features.\n", + " \"\"\"\n", + "\n", + " def _adb_attribute_to_dgl_feature(self, key: str, col: str, val):\n", + " \"\"\"\n", + " Given an ArangoDB attribute key, its assigned value (for an arbitrary document),\n", + " and the collection it belongs to, convert it to a valid\n", + " DGL feature: https://docs.dgl.ai/en/0.6.x/guide/graph-feature.html.\n", + "\n", + " NOTE: You must override this function if you want to transfer non-numerical\n", + " ArangoDB attributes to DGL (DGL only accepts 'attributes' (a.k.a features)\n", + " of numerical types). Read more about DGL features here:\n", + " https://docs.dgl.ai/en/0.6.x/new-tutorial/2_dglgraph.html#assigning-node-and-edge-features-to-graph.\n", + "\n", + " :param key: The ArangoDB attribute key name\n", + " :type key: str\n", + " :param col: The ArangoDB collection of the ArangoDB document.\n", + " :type col: str\n", + " :param val: The assigned attribute value of the ArangoDB document.\n", + " :type val: Any\n", + " :return: The attribute's representation as a DGL Feature\n", + " :rtype: Any\n", + " \"\"\"\n", + " try:\n", + " if col == \"transaction\":\n", + " if key == \"transaction_date\":\n", + " return int(str(val).replace(\"-\", \"\"))\n", + " \n", + " if key == \"trans_time\":\n", + " return int(str(val).replace(\":\", \"\"))\n", + " \n", + " if col == \"customer\":\n", + " if key == \"Sex\":\n", + " return 0 if val == \"M\" else 1\n", + "\n", + " if key == \"Ssn\":\n", + " return int(str(val).replace(\"-\", \"\"))\n", + "\n", + " if col == \"Class\":\n", + " if key == \"name\":\n", + " if val == \"Bank\":\n", + " return 0\n", + " elif val == \"Branch\":\n", + " return 1\n", + " elif val == \"Account\":\n", + " return 2\n", + " elif val == \"Customer\":\n", + " return 3\n", + " else:\n", + " return -1\n", + " except (ValueError, TypeError, SyntaxError):\n", + " return 0\n", + "\n", + " return super()._adb_attribute_to_dgl_feature(key, col, val)\n", + "\n", + "fraud_adbdgl_adapter = ADBDGL_Adapter(con, FraudDetection_ADBDGL_Controller())\n", + "\n", + "# Create DGL Graph from attributes\n", + "dgl_g = fraud_adbdgl_adapter.arangodb_to_dgl('FraudDetection', fraud_detection_metagraph)\n", + "\n", + "# You can also provide valid Python-Arango AQL query options to the command above, like such:\n", + "# dgl_g = fraud_adbdgl_adapter.arangodb_to_dgl(graph_name = 'FraudDetection', fraud_detection_metagraph, ttl=1000, stream=True)\n", + "# See more here: https://docs.python-arango.com/en/main/specs.html#arango.aql.AQL.execute\n", + "\n", + "# Show graph data\n", + "print('\\n--------------')\n", + "print(dgl_g)\n", + "print('\\n--------------')\n", + "print(dgl_g.ndata)\n", + "print('--------------\\n')\n", + "print(dgl_g.edata)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bvzJXSHHTi3v" + }, + "source": [ + "# DGL to ArangoDB" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UafSB_3JZNwK" + }, + "source": [ + "## Example 1: DGL Karate Graph" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tx-tjPfx0U_h" + }, + "source": [ + "Data source\n", + "* [DGL Karate Graph](https://docs.dgl.ai/en/0.6.x/api/python/dgl.data.html#karate-club-dataset)\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.dgl_to_arangodb()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L199-L297)\n", + "\n", + "Important notes\n", + "* The `name` parameter in this case is simply for naming your ArangoDB graph." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "eRVbiBy4ZdE4", + "outputId": "da33e345-87d7-442f-fbb7-5484b79889a5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ArangoDB: Karate created\n", + "\n", + "--------------------\n", + "https://tutorials.arangodb.cloud:8529\n", + "Username: TUT487i8kal98gb73c2iklds\n", + "Password: TUTn5t85w8t50kcupmo2mmyb\n", + "Database: TUTn187e39v9qho3768ilyk4\n", + "--------------------\n", + "\n", + "Inspect the graph here: https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Karate\n", + "\n", + "View the original graph below:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load the dgl graph & draw\n", + "dgl_karate_graph = KarateClubDataset()[0]\n", + "nx.draw(dgl_karate_graph.to_networkx(), with_labels=True)\n", + "\n", + "# Create the ArangoDB graph\n", + "name = \"Karate\"\n", + "db.delete_graph(name, drop_collections=True, ignore_missing=True)\n", + "adb_karate_graph = adbdgl_adapter.dgl_to_arangodb(name, dgl_karate_graph)\n", + "\n", + "print('\\n--------------------')\n", + "print(\"https://{}:{}\".format(con[\"hostname\"], con[\"port\"]))\n", + "print(\"Username: \" + con[\"username\"])\n", + "print(\"Password: \" + con[\"password\"])\n", + "print(\"Database: \" + con[\"dbName\"])\n", + "print('--------------------\\n')\n", + "print(f\"Inspect the graph here: https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{name}\\n\")\n", + "print(f\"View the original graph below:\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gshTlSX_ZZsS" + }, + "source": [ + "\n", + "## Example 2: DGL MiniGCDataset Graphs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KaExiE2x0-M6" + }, + "source": [ + "Data source\n", + "* [DGL Mini Graph Classification Dataset](https://docs.dgl.ai/en/0.6.x/api/python/dgl.data.html#mini-graph-classification-dataset)\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.dgl_to_arangodb()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L199-L297)\n", + "\n", + "Important notes\n", + "* The `name` parameters in this case are simply for naming your ArangoDB graph." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "dADiexlAioGH", + "outputId": "f7926863-61bb-4202-ba7e-e55413d20ca5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ArangoDB: Lollipop created\n", + "ArangoDB: Hypercube created\n", + "ArangoDB: Clique created\n", + "\n", + "--------------------\n", + "https://tutorials.arangodb.cloud:8529\n", + "Username: TUT487i8kal98gb73c2iklds\n", + "Password: TUTn5t85w8t50kcupmo2mmyb\n", + "Database: TUTn187e39v9qho3768ilyk4\n", + "--------------------\n", + "\n", + "\n", + "Inspect the graphs here:\n", + "\n", + "1) https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Lollipop\n", + "2) https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Hypercube\n", + "3) https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Clique\n", + "\n", + "\n", + "View the original graphs below:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load the dgl graphs & draw\n", + "dgl_lollipop_graph = remove_self_loop(MiniGCDataset(8, 7, 8)[3][0])\n", + "plt.figure(1)\n", + "nx.draw(dgl_lollipop_graph.to_networkx(), with_labels=True)\n", + "\n", + "dgl_hypercube_graph = remove_self_loop(MiniGCDataset(8, 8, 9)[4][0])\n", + "plt.figure(2)\n", + "nx.draw(dgl_hypercube_graph.to_networkx(), with_labels=True)\n", + "\n", + "dgl_clique_graph = remove_self_loop(MiniGCDataset(8, 6, 7)[6][0])\n", + "plt.figure(3)\n", + "nx.draw(dgl_clique_graph.to_networkx(), with_labels=True)\n", + "\n", + "# Create the ArangoDB graphs\n", + "lollipop = \"Lollipop\"\n", + "hypercube = \"Hypercube\"\n", + "clique = \"Clique\"\n", + "\n", + "db.delete_graph(lollipop, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(hypercube, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(clique, drop_collections=True, ignore_missing=True)\n", + "\n", + "adb_lollipop_graph = adbdgl_adapter.dgl_to_arangodb(lollipop, dgl_lollipop_graph)\n", + "adb_hypercube_graph = adbdgl_adapter.dgl_to_arangodb(hypercube, dgl_hypercube_graph)\n", + "adb_clique_graph = adbdgl_adapter.dgl_to_arangodb(clique, dgl_clique_graph)\n", + "\n", + "print('\\n--------------------')\n", + "print(\"https://{}:{}\".format(con[\"hostname\"], con[\"port\"]))\n", + "print(\"Username: \" + con[\"username\"])\n", + "print(\"Password: \" + con[\"password\"])\n", + "print(\"Database: \" + con[\"dbName\"])\n", + "print('--------------------\\n')\n", + "print(\"\\nInspect the graphs here:\\n\")\n", + "print(f\"1) https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{lollipop}\")\n", + "print(f\"2) https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{hypercube}\")\n", + "print(f\"3) https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{clique}\\n\")\n", + "print(f\"\\nView the original graphs below:\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CNj1xKhwoJoL" + }, + "source": [ + "\n", + "## Example 3: DGL MiniGCDataset Graphs with a custom controller" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CZ1UX9YX1Zzo" + }, + "source": [ + "Data source\n", + "* [DGL Mini Graph Classification Dataset](https://docs.dgl.ai/en/0.6.x/api/python/dgl.data.html#mini-graph-classification-dataset)\n", + "\n", + "Package methods used\n", + "* [`adbdgl_adapter.adapter.dgl_to_arangodb()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/adapter.py#L199-L297)\n", + "* [`adbdgl_adapter.controller._dgl_feature_to_adb_attribute()`](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L49-L70)\n", + "\n", + "Important notes\n", + "* The `name` parameters in this case are simply for naming your ArangoDB graph.\n", + "* We are creating a custom `ADBDGL_Controller` to specify *how* to convert our DGL node/edge features into ArangoDB vertex/edge attributes. View the default `ADBDGL_Controller` [here](https://github.com/arangoml/dgl-adapter/blob/1.0.1/adbdgl_adapter/controller.py#L11)." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jbJsvMMaoJoT", + "outputId": "7cc01a20-201b-42ea-85e7-c60d0d8d2fbb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connecting to https://tutorials.arangodb.cloud:8529\n", + "ArangoDB: Lollipop_With_Attributes created\n", + "ArangoDB: Hypercube_With_Attributes created\n", + "ArangoDB: Clique_With_Attributes created\n", + "\n", + "--------------------\n", + "https://tutorials.arangodb.cloud:8529\n", + "Username: TUT487i8kal98gb73c2iklds\n", + "Password: TUTn5t85w8t50kcupmo2mmyb\n", + "Database: TUTn187e39v9qho3768ilyk4\n", + "--------------------\n", + "\n", + "\n", + "Inspect the graphs here:\n", + "\n", + "1) https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Lollipop_With_Attributes\n", + "2) https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Hypercube_With_Attributes\n", + "3) https://tutorials.arangodb.cloud:8529/_db/TUTn187e39v9qho3768ilyk4/_admin/aardvark/index.html#graph/Clique_With_Attributes\n", + "\n" + ] + } + ], + "source": [ + "from torch.functional import Tensor\n", + "\n", + "# Load the dgl graphs\n", + "dgl_lollipop_graph = remove_self_loop(MiniGCDataset(8, 7, 8)[3][0])\n", + "dgl_hypercube_graph = remove_self_loop(MiniGCDataset(8, 8, 9)[4][0])\n", + "dgl_clique_graph = remove_self_loop(MiniGCDataset(8, 6, 7)[6][0])\n", + "\n", + " # Add DGL Node & Edge Features to each graph\n", + "dgl_lollipop_graph.ndata[\"random_ndata\"] = torch.tensor(\n", + " [[i, i, i] for i in range(0, dgl_lollipop_graph.num_nodes())]\n", + ")\n", + "dgl_lollipop_graph.edata[\"random_edata\"] = torch.rand(dgl_lollipop_graph.num_edges())\n", + "\n", + "dgl_hypercube_graph.ndata[\"random_ndata\"] = torch.rand(dgl_hypercube_graph.num_nodes())\n", + "dgl_hypercube_graph.edata[\"random_edata\"] = torch.tensor(\n", + " [[[i], [i], [i]] for i in range(0, dgl_hypercube_graph.num_edges())]\n", + ")\n", + "\n", + "dgl_clique_graph.ndata['clique_ndata'] = torch.tensor([1,2,3,4,5,6])\n", + "dgl_clique_graph.edata['clique_edata'] = torch.tensor(\n", + " [1 if i % 2 == 0 else 0 for i in range(0, dgl_clique_graph.num_edges())]\n", + ")\n", + "\n", + "\n", + "# When converting to ArangoDB from DGL, a user-defined Controller class\n", + "# is required to specify how DGL features (aka attributes) should be converted \n", + "# into ArangoDB attributes. NOTE: A custom Controller is NOT needed you want to\n", + "# keep the numerical-based values of your DGL features.\n", + "class Clique_ADBDGL_Controller(ADBDGL_Controller):\n", + " \"\"\"ArangoDB-DGL controller.\n", + "\n", + " Responsible for controlling how ArangoDB attributes\n", + " are converted into DGL features, and vice-versa.\n", + "\n", + " You can derive your own custom ADBDGL_Controller if you want to maintain\n", + " consistency between your ArangoDB attributes & your DGL features.\n", + " \"\"\"\n", + "\n", + " def _dgl_feature_to_adb_attribute(self, key: str, col: str, val: Tensor):\n", + " \"\"\"\n", + " Given a DGL feature key, its assigned value (for an arbitrary node or edge),\n", + " and the collection it belongs to, convert it to a valid ArangoDB attribute\n", + " (e.g string, list, number, ...).\n", + "\n", + " NOTE: No action is needed here if you want to keep the numerical-based values\n", + " of your DGL features.\n", + "\n", + " :param key: The DGL attribute key name\n", + " :type key: str\n", + " :param col: The ArangoDB collection of the (soon-to-be) ArangoDB document.\n", + " :type col: str\n", + " :param val: The assigned attribute value of the DGL node.\n", + " :type val: Tensor\n", + " :return: The feature's representation as an ArangoDB Attribute\n", + " :rtype: Any\n", + " \"\"\"\n", + " if key == \"clique_ndata\":\n", + " if val == 1:\n", + " return \"one is fun\"\n", + " elif val == 2:\n", + " return \"two is blue\"\n", + " elif val == 3:\n", + " return \"three is free\"\n", + " elif val == 4:\n", + " return \"four is more\"\n", + " else: # No special string for values 5 & 6\n", + " return f\"ERROR! Unrecognized value, got {val}\"\n", + "\n", + " if key == \"clique_edata\":\n", + " return bool(val)\n", + "\n", + " return super()._dgl_feature_to_adb_attribute(key, col, val)\n", + "\n", + "# Re-instantiate a new adapter specifically for the Clique Graph Conversion\n", + "clique_adbgl_adapter = ADBDGL_Adapter(con, Clique_ADBDGL_Controller())\n", + "\n", + "# Create the ArangoDB graphs\n", + "lollipop = \"Lollipop_With_Attributes\"\n", + "hypercube = \"Hypercube_With_Attributes\"\n", + "clique = \"Clique_With_Attributes\"\n", + "\n", + "db.delete_graph(lollipop, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(hypercube, drop_collections=True, ignore_missing=True)\n", + "db.delete_graph(clique, drop_collections=True, ignore_missing=True)\n", + "\n", + "adb_lollipop_graph = adbdgl_adapter.dgl_to_arangodb(lollipop, dgl_lollipop_graph)\n", + "adb_hypercube_graph = adbdgl_adapter.dgl_to_arangodb(hypercube, dgl_hypercube_graph)\n", + "adb_clique_graph = clique_adbgl_adapter.dgl_to_arangodb(clique, dgl_clique_graph) # Notice the new adapter here!\n", + "\n", + "print('\\n--------------------')\n", + "print(\"https://{}:{}\".format(con[\"hostname\"], con[\"port\"]))\n", + "print(\"Username: \" + con[\"username\"])\n", + "print(\"Password: \" + con[\"password\"])\n", + "print(\"Database: \" + con[\"dbName\"])\n", + "print('--------------------\\n')\n", + "print(\"\\nInspect the graphs here:\\n\")\n", + "print(f\"1) https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{lollipop}\")\n", + "print(f\"2) https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{hypercube}\")\n", + "print(f\"3) https://tutorials.arangodb.cloud:8529/_db/{con['dbName']}/_admin/aardvark/index.html#graph/{clique}\\n\")" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "ot1oJqn7m78n", + "QfE_tKxneG9A", + "ZrEDmtqCVD0W", + "RQ4CknYfUEuz", + "qEH6OdSB23Ya", + "DqIKT1lO4ASw", + "UafSB_3JZNwK", + "gshTlSX_ZZsS", + "CNj1xKhwoJoL" + ], + "name": "ArangoDB_DGL_Adapter_v1.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}