e2e-demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "DB_ULR = \"neo4j://localhost:7687\"\n",
    "DB_USER = \"neo4j\"\n",
    "DB_PASS = \"test1234\"\n",
    "DB_NAME = \"events\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create driver\n",
    "Also set the DB_NAME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import plotly.graph_objects as go\n",
    "from neo4j import GraphDatabase # Python database driver\n",
    "from graphdatascience import GraphDataScience # Python GDS client\n",
    "\n",
    "# And some cermony to create the driver and gds objects\n",
    "driver = GraphDatabase.driver(DB_ULR, auth=(DB_USER, DB_PASS))\n",
    "gds = GraphDataScience.from_neo4j_driver(driver=driver)\n",
    "gds.set_database(DB_NAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.4.6'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gds.version()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create databse and schema"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empty DataFrame\n",
      "Columns: []\n",
      "Index: []\n"
     ]
    }
   ],
   "source": [
    "# Create (or replace) database\n",
    "with driver.session(database = \"system\") as session:\n",
    "    result = session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"create database {dbname} if not exists\".format(dbname = DB_NAME)\n",
    "            #\"create database {dbname} if not exists options {{ storeFormat: 'aligned'}}\".format(dbname = DB_NAME)\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create indexes and constraints\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"CREATE CONSTRAINT IF NOT EXISTS FOR (n:Visitor) REQUIRE (n.id) IS NODE KEY\"\n",
    "            \"create constraint if not exists for (n:Person) require (n.dateOfBirth) is ::Date\"\n",
    "        ).consume()\n",
    "    )\n",
    "    session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"CREATE CONSTRAINT IF NOT EXISTS FOR (n:Item) REQUIRE (n.id) IS NODE KEY\"\n",
    "        ).consume()     \n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>timestamp</th>\n",
       "      <th>visitorid</th>\n",
       "      <th>event</th>\n",
       "      <th>itemid</th>\n",
       "      <th>transactionid</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1433221332117</td>\n",
       "      <td>257597</td>\n",
       "      <td>view</td>\n",
       "      <td>355908</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1433224214164</td>\n",
       "      <td>992329</td>\n",
       "      <td>view</td>\n",
       "      <td>248676</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1433221999827</td>\n",
       "      <td>111016</td>\n",
       "      <td>view</td>\n",
       "      <td>318965</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1433221955914</td>\n",
       "      <td>483717</td>\n",
       "      <td>view</td>\n",
       "      <td>253185</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1433221337106</td>\n",
       "      <td>951259</td>\n",
       "      <td>view</td>\n",
       "      <td>367447</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       timestamp  visitorid event  itemid  transactionid\n",
       "0  1433221332117     257597  view  355908            NaN\n",
       "1  1433224214164     992329  view  248676            NaN\n",
       "2  1433221999827     111016  view  318965            NaN\n",
       "3  1433221955914     483717  view  253185            NaN\n",
       "4  1433221337106     951259  view  367447            NaN"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read csv file\n",
    "# Source https://www.kaggle.com/retailrocket/ecommerce-dataset?select=events.csv\n",
    "csv = pd.read_csv('/Users/haklof/datasets/events.csv')\n",
    "csv.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    257597\n",
       "1    992329\n",
       "2    111016\n",
       "3    483717\n",
       "4    951259\n",
       "Name: visitorid, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select all unique visitors\n",
    "visitors = csv['visitorid'].drop_duplicates().dropna()\n",
    "visitors.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n",
      "   nodesCreated\n",
      "0        140758\n"
     ]
    }
   ],
   "source": [
    "# Create Visitor nodes\n",
    "for chunk in np.array_split(visitors, 10):\n",
    "    with driver.session(database = DB_NAME) as session:\n",
    "        result = session.execute_write( lambda tx: \n",
    "            tx.run(\n",
    "                \"\"\"\n",
    "                UNWIND $visitors as visitorId\n",
    "                CREATE (n:Visitor{id: visitorId})\n",
    "                RETURN count(*) as nodesCreated\n",
    "                \"\"\",\n",
    "                visitors = chunk.to_list()\n",
    "            ).data()\n",
    "        )\n",
    "        df = pd.DataFrame(result)\n",
    "        print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0          355908\n",
      "1          248676\n",
      "2          318965\n",
      "3          253185\n",
      "4          367447\n",
      "            ...  \n",
      "2756002     19206\n",
      "2756039    172413\n",
      "2756042       613\n",
      "2756060     52086\n",
      "2756062    177353\n",
      "Name: itemid, Length: 235061, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Select all unique Items\n",
    "items = csv['itemid'].drop_duplicates().dropna()\n",
    "print(items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   nodesCreated\n",
      "0        235061\n"
     ]
    }
   ],
   "source": [
    "# Create Item nodes\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            UNWIND $items as itemId\n",
    "            MERGE (:Item{id: itemId})\n",
    "            RETURN count(*) as nodesCreated\n",
    "            \"\"\",\n",
    "            items = items.to_list()\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         visitorid  itemid      timestamp\n",
      "0           257597  355908  1433221332117\n",
      "1           992329  248676  1433224214164\n",
      "2           111016  318965  1433221999827\n",
      "3           483717  253185  1433221955914\n",
      "4           951259  367447  1433221337106\n",
      "...            ...     ...            ...\n",
      "2756096     591435  261427  1438398785939\n",
      "2756097     762376  115946  1438399813142\n",
      "2756098    1251746   78144  1438397820527\n",
      "2756099    1184451  283392  1438398530703\n",
      "2756100     199536  152913  1438400163914\n",
      "\n",
      "[2664312 rows x 3 columns]\n"
     ]
    }
   ],
   "source": [
    "# Select all VIEWD relationships\n",
    "viewed = csv[csv['event'] == 'view'][['visitorid','itemid', 'timestamp']]\n",
    "print(viewed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133216\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n",
      "   relsCreated\n",
      "0       133215\n"
     ]
    }
   ],
   "source": [
    "# Create VIEWED relationships\n",
    "for chunk in np.array_split(viewed, 20):\n",
    "    with driver.session(database = DB_NAME) as session:\n",
    "        result = session.execute_write( lambda tx: \n",
    "            tx.run(\n",
    "                \"\"\"\n",
    "                UNWIND $data as rel\n",
    "                MATCH (i:Item{id: rel.itemid}), (v:Visitor{id: rel.visitorid})\n",
    "                MERGE (v)-[:VIEWED{timestamp:  datetime({epochMillis: rel.timestamp})}]->(i)\n",
    "                RETURN count(*) as relsCreated\n",
    "                \"\"\",\n",
    "                data = chunk.to_dict('records')\n",
    "            ).data()\n",
    "        )\n",
    "        df = pd.DataFrame(result)\n",
    "        print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         visitorid  itemid      timestamp\n",
      "17          287857    5206  1433223236124\n",
      "19          158090   10572  1433221078505\n",
      "63         1193904  255275  1433223543021\n",
      "112         599528  356475  1433221941632\n",
      "179         105775  312728  1433220880956\n",
      "...            ...     ...            ...\n",
      "2755956     831605   57810  1438400400805\n",
      "2756056      10670  419736  1438398156086\n",
      "2756074     144106  141241  1438400994744\n",
      "2756078     804736  447661  1438399807937\n",
      "2756090     804736  346534  1438399811281\n",
      "\n",
      "[69332 rows x 3 columns]\n"
     ]
    }
   ],
   "source": [
    "# Select all ADDED relationships\n",
    "added = csv[csv['event'] == 'addtocart'][['visitorid','itemid', 'timestamp']]\n",
    "print(added)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   relsCreated\n",
      "0        69332\n"
     ]
    }
   ],
   "source": [
    "# Create ADDED relationships\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            UNWIND $data as rel\n",
    "            MATCH (i:Item{id: rel.itemid}), (v:Visitor{id: rel.visitorid})\n",
    "            CREATE (v)-[:ADDED{timestamp:  datetime({epochMillis: rel.timestamp})}]->(i)\n",
    "            RETURN count(*) as relsCreated\n",
    "            \"\"\",\n",
    "            data = added.to_dict('records')\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         visitorid  itemid      timestamp  transactionid\n",
      "130         599528  356475  1433222276276           4000\n",
      "304         121688   15335  1433193500981          11117\n",
      "418         552148   81345  1433193915008           5444\n",
      "814         102019  150318  1433176736375          13556\n",
      "843         189384  310791  1433174518180           7244\n",
      "...            ...     ...            ...            ...\n",
      "2755294    1050575   31640  1438377176570           8354\n",
      "2755349     861299  456602  1438379878779           3643\n",
      "2755508     855941  235771  1438357730123           4385\n",
      "2755603     548772   29167  1438355560300          13872\n",
      "2755607    1051054  312728  1438358989163          17579\n",
      "\n",
      "[22457 rows x 4 columns]\n"
     ]
    }
   ],
   "source": [
    "# Select all BOUGHT relationships\n",
    "bought = csv[csv['event'] == 'transaction'][['visitorid','itemid', 'timestamp', 'transactionid']]\n",
    "bought.transactionid = bought.transactionid.astype(int)\n",
    "print(bought)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   relsCreated\n",
      "0        22457\n"
     ]
    }
   ],
   "source": [
    "# Create BOUGHT relationships\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            UNWIND $data as rel\n",
    "            MATCH (i:Item{id: rel.itemid}), (v:Visitor{id: rel.visitorid})\n",
    "            CREATE (v)-[:BOUGHT{timestamp: datetime({epochMillis: rel.timestamp}), transactionid: rel.transactionid}]->(i)\n",
    "            RETURN count(*) as relsCreated\n",
    "            \"\"\",\n",
    "            data = bought.to_dict('records')\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some basic queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   itemid  times_bought  times_added  times_viewed\n",
      "0  461686           133          306          2538\n",
      "1  119736            97           44           752\n",
      "2  213834            92           17           293\n",
      "3    7943            46           97          1346\n",
      "4  312728            46          162           947\n",
      "5  445351            45           89           939\n",
      "6   48030            41           95           986\n",
      "7  248455            38           52           575\n",
      "8  420960            38           60           795\n",
      "9   17478            37           72           631\n"
     ]
    }
   ],
   "source": [
    "# Top sellers\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_read( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            MATCH (i:Item)<-[:BOUGHT]-()\n",
    "            RETURN  i.id as itemid, \n",
    "                    count(*) as times_bought,\n",
    "                    count { (i:Item)<-[:ADDED]-() } as times_added,\n",
    "                    count { (i:Item)<-[:VIEWED]-() } as times_viewed\n",
    "            ORDER BY times_bought desc limit $limit\n",
    "            \"\"\",\n",
    "            limit = 10\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>product_bought</th>\n",
       "      <th>times_bought</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>119736</td>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>213834</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>171878</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>248455</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10572</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   product_bought  times_bought\n",
       "0          119736            59\n",
       "1          213834            18\n",
       "2          171878            13\n",
       "3          248455            12\n",
       "4           10572            11"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Collaberative filtering\n",
    "# Suggest what other Items Visitors buy for a Visitor veiwing an Item (where the Visitor has not added/bought the Item already)\n",
    "result = None\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_read( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            MATCH (i:Item{id: $itemid})<-[:VIEWED]-(visitor)-[bought:BOUGHT]->(otherItem)\n",
    "            WHERE i <> otherItem\n",
    "            AND NOT (:Visitor{id: $visitorid})-[:BOUGHT|ADDED]->(otherItem)\n",
    "            RETURN  otherItem.id as product_bought, \n",
    "                    count(distinct bought) as times_bought\n",
    "            ORDER BY times_bought desc limit $limit\n",
    "            \"\"\",\n",
    "            limit = 10, itemid = 461686, visitorid=201110\n",
    "        ).to_df()\n",
    "    )\n",
    "result.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   product_bought  times_bought_together\n",
      "0          171878                      9\n",
      "1          218794                      8\n",
      "2           32581                      8\n",
      "3           10572                      8\n",
      "4          124081                      4\n",
      "5          447067                      3\n",
      "6           75392                      3\n",
      "7          108924                      3\n",
      "8           40630                      2\n",
      "9          192043                      2\n"
     ]
    }
   ],
   "source": [
    "# Collaberative filtering (alternative)\n",
    "# Suggest based on what other items that were checked out in same transaction\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_read( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            MATCH (i:Item{id: $itemid})<-[b1:BOUGHT]-(visitor)-[b2:BOUGHT]->(otherItem)\n",
    "            WHERE i <> otherItem\n",
    "            AND b1.transactionid = b2.transactionid\n",
    "            AND NOT (:Visitor{id: $visitorid})-[:BOUGHT|ADDED]->(otherItem)\n",
    "            RETURN  otherItem.id as product_bought, \n",
    "                    count(distinct b1.transactionid) as times_bought_together\n",
    "            ORDER BY times_bought_together desc limit $limit\n",
    "            \"\"\",\n",
    "            limit = 10, itemid = 461686, visitorid=201110\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Questions so far?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Graph data science"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    max  p0.999  p0.99  p0.90  p0.75  min\n",
      "0  7757    47.0   13.0    3.0    2.0    1\n"
     ]
    }
   ],
   "source": [
    "# Do we have any \"abnormal visitors\"\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_read( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            MATCH (v:Visitor)-[:VIEWED|ADDED|BOUGHT]->()\n",
    "            WITH v, \n",
    "                 count(*) as number_of_events\n",
    "            RETURN  max(number_of_events) as `max`,\n",
    "                    percentileCont(number_of_events, 0.999) as `p0.999`,\n",
    "                    percentileCont(number_of_events, 0.99) as `p0.99`,\n",
    "                    percentileCont(number_of_events, 0.9) as `p0.90`,\n",
    "                    percentileCont(number_of_events, 0.75) as `p0.75`,\n",
    "                    min(number_of_events) as `min`\n",
    "            \"\"\",\n",
    "            limit = 10\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   number_of_abnormal_visitors\n",
      "0                         1225\n"
     ]
    }
   ],
   "source": [
    "# Re-label abnormal visitors\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_write( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            MATCH (v:Visitor)-[:VIEWED|ADDED|BOUGHT]->()\n",
    "            WITH v, \n",
    "                 count(*) as number_of_events\n",
    "            WHERE number_of_events > 50\n",
    "            SET v:AbnormalVisitor\n",
    "            REMOVE v:Visitor\n",
    "            RETURN count(*) as number_of_abnormal_visitors\n",
    "            \"\"\",\n",
    "            limit = 10\n",
    "        ).data()\n",
    "    )\n",
    "    df = pd.DataFrame(result)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to do it from the neo4j browser / cypher shell\n",
    "```cypher\n",
    "call gds.graph.create.cypher(\n",
    "    'items',\n",
    "    'MATCH (i:Item) return id(i) as id',\n",
    "    'MATCH (i1:Item)<-[r1:VIEWED]-(v:Visitor)-[r2:VIEWED|ADDED|BOUGHT]->(i2:Item)\n",
    "     WHERE r1.timestamp<r2.timestamp\n",
    "     WITH i1, i2, r1, case type(r2) when \"BOUGHT\" then 1.0 when \"ADDED\" then 0.7 else 0.2 end as weight\n",
    "     RETURN id(i1) as target, id(i2) as source, weight',\n",
    "     {readConcurrency:16}\n",
    ")\n",
    "\n",
    "call gds.pageRank.stats('items', {maxIterations:200, relationshipWeightProperty:'weight', concurrency:16})\n",
    "\n",
    "call gds.pageRank.write('items', {maxIterations:200, relationshipWeightProperty:'weight', concurrency:16, writeProperty:'pagerank'})\n",
    "\n",
    "call gds.graph.drop('items')\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to do it with the GraphDataScience python wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "630329e2d40e4d5b9a2253f992c5a8b7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Loading:   0%|          | 0/100 [00:00<?, ?%/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "nodeQuery                            MATCH (i:Item) return id(i) as id\n",
       "relationshipQuery    MATCH (i1:Item)<-[r1:VIEWED]-(v:Visitor)-[r2:V...\n",
       "graphName                                                        items\n",
       "nodeCount                                                       235061\n",
       "relationshipCount                                              5018193\n",
       "projectMillis                                                     7205\n",
       "Name: 0, dtype: object"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G, project_stats = gds.graph.project.cypher(\n",
    "    'items',\n",
    "    \"\"\"\n",
    "    MATCH (i:Item) return id(i) as id\n",
    "    \"\"\",\n",
    "    \"\"\"\n",
    "        MATCH (i1:Item)<-[r1:VIEWED]-(v:Visitor)-[r2:VIEWED|ADDED|BOUGHT]->(i2:Item)\n",
    "        WHERE r1.timestamp<r2.timestamp\n",
    "        WITH i1, i2, r1, case type(r2) when \"BOUGHT\" then 1.0 when \"ADDED\" then 0.7 else 0.2 end as weight\n",
    "        RETURN id(i1) as target, id(i2) as source, weight\n",
    "     \"\"\",\n",
    "    readConcurrency=16\n",
    ")\n",
    "project_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a36029309f142beaa88f895d6d7fe50",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "PageRank:   0%|          | 0/100 [00:00<?, ?%/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "writeMillis                                                             293\n",
      "nodePropertiesWritten                                                235061\n",
      "ranIterations                                                           121\n",
      "didConverge                                                            True\n",
      "centralityDistribution    {'min': 0.14999961853027344, 'max': 110.653319...\n",
      "postProcessingMillis                                                    114\n",
      "preProcessingMillis                                                       0\n",
      "computeMillis                                                          2454\n",
      "configuration             {'writeProperty': 'pagerank', 'jobId': '6254cd...\n",
      "Name: 0, dtype: object\n"
     ]
    }
   ],
   "source": [
    "G = gds.graph.get('items')\n",
    "pagerankRes = gds.pageRank.write(G, maxIterations=200, relationshipWeightProperty='weight', concurrency=16, writeProperty='pagerank')\n",
    "print(pagerankRes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "graphName                                                            items\n",
       "database                                                            events\n",
       "memoryUsage                                                               \n",
       "sizeInBytes                                                             -1\n",
       "nodeCount                                                           235061\n",
       "relationshipCount                                                  5018193\n",
       "configuration            {'readConcurrency': 16, 'jobId': 'a84e9d31-5cd...\n",
       "density                                                           0.000091\n",
       "creationTime                           2023-10-02T15:58:41.917332000+02:00\n",
       "modificationTime                       2023-10-02T15:58:49.176105000+02:00\n",
       "schema                   {'graphProperties': {}, 'nodes': {'__ALL__': {...\n",
       "schemaWithOrientation    {'graphProperties': {}, 'nodes': {'__ALL__': {...\n",
       "Name: 0, dtype: object"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = gds.graph.get('items')\n",
    "G.drop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   product_bought       rank  times_bought\n",
      "0          257040  66.998162             4\n",
      "1          309778  65.395879             2\n",
      "2            9877  45.231441             8\n",
      "3          320130  41.140090             8\n",
      "4          445351  38.658325             6\n",
      "5          409804  38.333878             4\n",
      "6           29196  37.918723             2\n",
      "7           37029  36.671724             7\n",
      "8          369447  35.673712             1\n",
      "9          234255  35.013012             6\n"
     ]
    }
   ],
   "source": [
    "# Can we suggest an Item with high probability of conversion (central to conversion)\n",
    "with driver.session(database = DB_NAME) as session:\n",
    "    result = session.execute_read( lambda tx: \n",
    "        tx.run(\n",
    "            \"\"\"\n",
    "            MATCH (i:Item{id: $itemid})<-[:VIEWED]-(visitor)-[bought:BOUGHT]->(otherItem)\n",
    "            WHERE i <> otherItem\n",
    "            AND NOT (:Visitor{id: $visitorid})-[:BOUGHT|ADDED]->(otherItem)\n",
    "            RETURN  otherItem.id as product_bought,\n",
    "                    otherItem.pagerank as rank,\n",
    "                    count(distinct bought) as times_bought\n",
    "            ORDER BY rank desc limit $limit\n",
    "            \"\"\",\n",
    "            limit = 10, itemid = 461686, visitorid=684514\n",
    "        ).data()\n",
    "    )\n",
    "df = pd.DataFrame(result)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('notebooks')",
   "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.16"
  },
  "vscode": {
   "interpreter": {
    "hash": "c68434ca16130d73e64183f54aeda16ecffce872c062f16976fd0d983519d848"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}