paysim-fastRP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegressionCV\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "from neo4j import GraphDatabase"
   ]
  },
  {
   "source": [
    "driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"test1234\"), encrypted=False)"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createGraphProjection(tx):\n",
    "    return tx.run(\n",
    "        \"\"\"CALL gds.graph.create(\n",
    "            'payment', \n",
    "            'Client', \n",
    "            { PAYS: { type: 'PAYS', orientation:'NATURAL'}}, \n",
    "            {\n",
    "                nodeProperties: { },\n",
    "                relationshipProperties: {amount: { property: 'amount', aggregation: 'NONE', defaultValue: 0.0 }}\n",
    "            }\n",
    "        )\"\"\"\n",
    "    ).consume()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def runFastRP(tx): \n",
    "    return tx.run(\n",
    "        \"\"\"CALL gds.fastRP.write(\n",
    "            'payment', \n",
    "            {\n",
    "                embeddingDimension: 8,\n",
    "                iterationWeights: [0.0, 0.20, 0.40, 0.60, 0.80, 1.00, 1.20, 1.40, 1.60, 1.80, 2.00],\n",
    "                relationshipWeightProperty: 'amount',\n",
    "                writeProperty:'fastRP'\n",
    "            }\n",
    "            )\"\"\"\n",
    "    ).consume()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dropGraphProjection(tx):\n",
    "    return tx.run(\"CALL gds.graph.drop('payment')\").consume()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getEmbeddings(tx, embedding, category, nodeIds):\n",
    "    data = tx.run(\"MATCH (c:Client) where exists(c.fastRP) with c, c:Mule as isMule RETURN {id: c.id, embedding: c.fastRP, isMule:isMule} AS result limit 30000\")\n",
    "    for record in data: \n",
    "        embedding.append(record[\"result\"][\"embedding\"])\n",
    "        category.append(record[\"result\"][\"isMule\"])\n",
    "        nodeIds.append(record[\"result\"][\"id\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "<neo4j.work.summary.ResultSummary object at 0x139ba7a00>\n"
     ]
    }
   ],
   "source": [
    "# Create projection \n",
    "with driver.session(database = \"paysim\") as session:\n",
    "    result = session.read_transaction(createGraphProjection)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "<neo4j.work.summary.ResultSummary object at 0x105f54100>\n"
     ]
    }
   ],
   "source": [
    "# Run algorithm and write back result\n",
    "with driver.session(database = \"paysim\") as session:\n",
    "    result = session.write_transaction(runFastRP)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "<neo4j.work.summary.ResultSummary object at 0x139c312e0>\n"
     ]
    }
   ],
   "source": [
    "# Drop projection\n",
    "with driver.session(database = \"paysim\") as session:\n",
    "    result = session.read_transaction(dropGraphProjection)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding = []\n",
    "category = []\n",
    "nodeIds = []\n",
    "with driver.session(database = \"paysim\") as session:\n",
    "    session.read_transaction(getEmbeddings, embedding, category, nodeIds)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Array shapes:\n X_train = (15336, 8)\n y_train = (15336,)\n X_test = (6574, 8)\n y_test = (6574,)\n"
     ]
    }
   ],
   "source": [
    "# X will hold the n-dimensional input features\n",
    "X = np.array(embedding)\n",
    "# y holds the corresponding target values\n",
    "y = np.array(category)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, test_size=None)\n",
    "\n",
    "print(\n",
    "    \"Array shapes:\\n X_train = {}\\n y_train = {}\\n X_test = {}\\n y_test = {}\".format(\n",
    "        X_train.shape, y_train.shape, X_test.shape, y_test.shape\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done  10 out of  10 | elapsed:    1.1s finished\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "LogisticRegressionCV(cv=10, max_iter=300, multi_class='ovr', scoring='accuracy',\n",
       "                     verbose=True)"
      ]
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "source": [
    "clf = LogisticRegressionCV(\n",
    "    Cs=10, cv=10, scoring=\"accuracy\", verbose=True, multi_class=\"ovr\", max_iter=300, solver='lbfgs'\n",
    ")\n",
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Feature: 0, Score: -0.07338\nFeature: 1, Score: -0.22293\nFeature: 2, Score: -0.02176\nFeature: 3, Score: 0.18499\nFeature: 4, Score: -0.49267\nFeature: 5, Score: 0.27256\nFeature: 6, Score: 0.49659\nFeature: 7, Score: -0.34022\n"
     ]
    }
   ],
   "source": [
    "# Feature Importance\n",
    "importance = clf.coef_[0]\n",
    "for i,v in enumerate(importance):\n",
    "\tprint('Feature: %0d, Score: %.5f' % (i,v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.9119257681776696"
      ]
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "source": [
    "accuracy_score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "              precision    recall  f1-score   support\n\n        True       0.49      1.00      0.66       556\n       False       1.00      0.90      0.95      6018\n\n    accuracy                           0.91      6574\n   macro avg       0.74      0.95      0.80      6574\nweighted avg       0.96      0.91      0.92      6574\n\ny_test mules = 556\ny_pred mules = 1135\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_test, y_pred, labels=[True, False]))\n",
    "print(\"y_test mules = {}\\ny_pred mules = {}\".format(np.count_nonzero(y_test == True), np.count_nonzero(y_pred == True) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  },
  "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.8.6-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}