labs/dataflow_in_ds_fraud_detection/Credit Card Fraud detection PySpark3.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) 2022 Oracle, Inc. All rights reserved. Licensed under the [Universal Permissive License v 1.0](https://oss.oracle.com/licenses/upl).\n",
    "\n",
    "---\n",
    "\n",
    "# <font color=\"red\">Train and Deploy Models from Massive Datasets</font>\n",
    "## <font color=\"red\">Credit Card Fraud Detection use-case</font>\n",
    "<p style=\"margin-left:10%; margin-right:10%;\">by the <font color=\"teal\">Oracle Cloud Infrastructure Data Science Service.</font></p>\n",
    "\n",
    "---\n",
    "\n",
    "# Overview:\n",
    "\n",
    "Credit card fraud is a major source of losses for any merchant, and the prevalence of this form of payment combined with the increase in online transactions makes it an important issue to try to tackle.\n",
    "\n",
    "However fraud is still a small fraction of all transactions and training a machine learning model for this purpose tends to require a vast amount of data.\n",
    "\n",
    "In this notebook, you will learn how to work with Spark within the [Data Science](https://docs.oracle.com/en-us/iaas/data-science/using/data-science.htm) service. [Spark](https://spark.apache.org/docs/latest/) is a distributed computing framework which is available as a service on Oracle Cloud Infrastructure (OCI) as [Data Flow](https://docs.oracle.com/en-us/iaas/data-flow/using/dfs_getting_started.htm); a fully managed Spark deployment.\n",
    "\n",
    "You will explore a synthetic dataset of credit card transactions, try models and evaluate their performance on this dataset. You will create Spark applications to run training and batch scoring on Oracle Cloud Infrastructure Data Flow, the Oracle serverless Spark platform, and then deploy a model inference server callable via a REST endpoint.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"feature1\"></a>\n",
    "## Prerequisites\n",
    "\n",
    "- Experience with the specific Topic: Intermediate.\n",
    "\n",
    "- Professional experience: None\n",
    "\n",
    "- To run this notebook, your tenancy needs to be set up to use Data Flow. See [https://docs.oracle.com/en-us/iaas/data-flow/using/dfs_getting_started.htm](https://docs.oracle.com/en-us/iaas/data-flow/using/dfs_getting_started.htm) to get started.\n",
    "\n",
    "- To run this notebook, use the PySpark CPU v4 conda environment. To install use:\n",
    "\n",
    "    ```\n",
    "    odsc conda install -s pyspark30_p37_cpu_v4\n",
    "    ```\n",
    "\n",
    "\n",
    "- The notebook requires an Object Storage bucket to store the code that will be created and used by Data Flow applications, and an Object Storage bucket for the data.\n",
    "\n",
    "- The data generation part of this use-case can be very time-consuming, depending on the amount of data you wish to generate. We recommend the use of the shape with at least 8 OCPUs. Generating terabytes of data can take several hours. To run this notebook, a medium-size dataset that can be generated in a few minutes is sufficient, but to obtain the best-performing model, training on the largest dataset is needed.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Contents:\n",
    "\n",
    "- <a href='#use_case'>Introduction</a>\n",
    "- <a href=\"#setup\">1. Setup</a>\n",
    "    - <a href=\"#variables\">1.1. Variables</a>\n",
    "    - <a href=\"#utilities\">1.2. Utility Functions</a>\n",
    "- <a href=\"#dataset\">2. Generate the Dataset</a>\n",
    "- <a href=\"#store_data\">3. Store Dataset on Object Storage</a>\n",
    "- <a href=\"#explore\">4. Explore the Dataset</a>\n",
    "    - <a href=\"#customer_info\">4.1. Customer Information</a>\n",
    "        - <a href=\"#age\">4.1.1. Customer Age</a>\n",
    "        - <a href=\"#gender\">4.1.2. Customer Gender</a>\n",
    "        - <a href=\"#city_population\">4.1.3. Customer City Population</a>\n",
    "    - <a href=\"#transaction_info\">4.2. Transaction Information</a>\n",
    "        - <a href=\"#day_of_week\">4.2.1. Day of Week</a>\n",
    "        - <a href=\"#weekend\">4.2.2. Weekend or Weekday</a>\n",
    "        - <a href=\"#month_of_year\">4.2.3. Month of the Year</a>\n",
    "        - <a href=\"#time_of_day\">4.2.4. Time of Day</a>\n",
    "        - <a href=\"#amount\">4.2.5. Transaction Amount</a>\n",
    "        - <a href=\"#category\">4.2.6. Merchant Category</a>\n",
    "        - <a href=\"#distance\">4.2.7. Distance to Merchant</a>\n",
    "- <a href=\"#features\">5. Feature Engineering</a>\n",
    "    - <a href=\"#build_features\">5.1. Build the feature set</a>\n",
    "    - <a href=\"#split_set\">5.2. Split Train and Test sets</a>\n",
    "    - <a href=\"#rebalance\">5.3. Balance Classes</a>\n",
    "    - <a href=\"#eval_helper\">5.4. Model Evaluation helper</a>\n",
    "- <a href=\"#model_selection\">6. Model Selection</a>\n",
    "    - <a href=\"#lr\">6.1. Logistic Regression Model</a>\n",
    "    - <a href=\"#dt\">6.2. Decision Tree Classifier Model</a>\n",
    "    - <a href=\"#rf\">6.3. Random Forest Classifier</a>\n",
    "    - <a href=\"#gbt\">6.4. Gradient Boosted Trees</a>\n",
    "- <a href=\"#df_training\">7. Running Training on OCI Data Flow</a>\n",
    "    - <a href=\"#training_script\">7.1. Data Flow Training Application script</a>\n",
    "    - <a href=\"#test_training\">7.2. Test the Data Flow Application script locally</a>\n",
    "    - <a href=\"#training_app\">7.3. Create the Data Flow Application</a>\n",
    "    - <a href=\"#training_run\">7.4. Create a Data Flow Training Run</a>\n",
    "    - <a href=\"#edit_script\">7.5. Editing Data Flow applications</a>\n",
    "- <a href=\"#df_scoring\">8. Create a Batch Scoring Application</a>\n",
    "    - <a href=\"#scoring_script\">8.1. Data Flow Batch Scoring Application script</a>\n",
    "    - <a href=\"#scoring_run\">8.2. Create a Data Flow Run for scoring</a>\n",
    "- <a href=\"#model_cat\">9. Create a Model in Model Catalog</a>\n",
    "    - <a href=\"#artifact\">9.1. Prepare the Model Artifact for Model Catalog</a>\n",
    "    - <a href=\"#model_script\">9.2. Create the Inference Model script</a>\n",
    "    - <a href=\"#pull_model\">9.3. Get the trained model into the model deployment folder</a>\n",
    "    - <a href=\"#save_to_cat\">9.4. Save the model into Model Catalog</a>\n",
    "    - <a href=\"#test_model\">9.5. Test the model locally</a>\n",
    "- <a href=\"#md\">10. Deploy the model</a>\n",
    "    - <a href=\"#md_create\">10.1 Create a Model Deployment and Endpoint</a>\n",
    "    - <a href=\"#test_md\">10.2 Test the Model Deployment Endpoint</a>\n",
    "- <a href=\"#clean\">11. Clean up</a>\n",
    "    - <a href=\"#md_clean\">11.1 Clean up model deployment</a>\n",
    "    - <a href=\"#clean_mc\">11.2 Remove the model from Model Catalog</a>\n",
    "    - <a href=\"#clean_mc\">11.3 Delete Data Flow applications</a>\n",
    "    - <a href=\"#clean_mc\">11.4 Delete Local files</a>\n",
    "    - <a href=\"#clean_mc\">11.5 Delete the datasets and dataset generator</a>\n",
    "- <a href=\"#reference\">References</a>\n",
    "\n",
    "---\n",
    "\n",
    "**Important:**\n",
    "\n",
    "Placeholder text for required values are surrounded by angle brackets that must be removed when adding the indicated content. For example, when adding a database name to `database_name = \"<database_name>\"` would become `database_name = \"production\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make sure ads is version 2.6.2 (2.6.3 to 2.6.6 had a bug)\n",
    "!pip install -U oracle-ads==2.6.2 --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ads\n",
    "import json\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import oci\n",
    "import ocifs\n",
    "import os\n",
    "import pandas as pd\n",
    "import pyspark\n",
    "import re\n",
    "import requests\n",
    "import sys\n",
    "\n",
    "from ads.catalog.model import ModelCatalog\n",
    "from ads.common.model_artifact import ModelArtifact\n",
    "from ads.common.model_export_util import prepare_generic_model\n",
    "from ads.dataflow.dataflow import DataFlow\n",
    "from ads.model.generic_model import GenericModel\n",
    "from ads.model.deployment import ModelDeployer\n",
    "\n",
    "from datetime import datetime\n",
    "from glob import glob\n",
    "\n",
    "from pyspark import SparkContext\n",
    "from pyspark.conf import SparkConf\n",
    "from pyspark.ml import Pipeline, PipelineModel\n",
    "from pyspark.ml.classification import DecisionTreeClassifier, GBTClassifier, LogisticRegression, RandomForestClassifier\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler\n",
    "from pyspark.ml.functions import vector_to_array\n",
    "\n",
    "from sklearn.metrics import auc, confusion_matrix, ConfusionMatrixDisplay, precision_recall_curve, \\\n",
    "                            PrecisionRecallDisplay, roc_auc_score, roc_curve, RocCurveDisplay\n",
    "\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.types import FloatType\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='use_case'></a>\n",
    "# Introduction\n",
    "\n",
    "<a id='setup'></a>\n",
    "## 1. Setup\n",
    "\n",
    "<a id='variables'></a>\n",
    "### 1.1 Variables\n",
    "\n",
    "Please populate the variables in the next cell with your own values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# home folder\n",
    "home_folder = '~/'\n",
    "# Object Storage tenancy namespace\n",
    "tenancy_namespace = '<namespace>'\n",
    "# Data bucket name, where the data will be stored\n",
    "data_bucket_name = '<bucket_name>'\n",
    "# code bucket name, where the Data Flow code will be stored\n",
    "code_bucket_name = '<bucket_name>'\n",
    "# logs bucket name, where Data Flow log files will be sent\n",
    "logs_bucket_name = '<bucket_name>'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configure resource principal for the local Spark context. This allow access to things like Object Storage from the local Spark instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The core-site.xml is being written to /home/datascience/spark_conf_dir/core-site.xml\n"
     ]
    }
   ],
   "source": [
    "!odsc core-site config --overwrite --authentication resource_principal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the Data Science environment does not use Resource Principal, you can set up authentication using an API key with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uncomment to use the following:\n",
    "# !odsc core-site config --overwrite --authentication api_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"utilities\"></a>\n",
    "### 1.2. Utility Functions\n",
    "\n",
    "In this section, you will define utility functions to get a Spark session. The way to obtain the Spark session depends on whether the code runs locally, in a Data Science Notebook or in Data Flow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_in_oci():\n",
    "    return os.environ.get(\"HOME\") == \"/home/dataflow\" or os.environ.get(\"HOME\") == \"/home/datascience\"\n",
    "\n",
    "def get_spark_session(\n",
    "        app_name, \n",
    "        file_location=None, \n",
    "        profile_name=None, \n",
    "        spark_config={}\n",
    "    ):\n",
    "    \"\"\"\n",
    "    Get a Spark session in a way that supports running locally or in Data Flow.\n",
    "    \"\"\"\n",
    "    \n",
    "    # If we are in Data Flow or Data Science, we assume the instance uses Instance Principal \n",
    "    # for authorization, and we can create a Spark Session Builder without config\n",
    "    if is_in_oci():\n",
    "        spark_builder = SparkSession.builder.appName(app_name)\n",
    "        \n",
    "    # If we run on a local machine, we need to provide authentication from the OCI config\n",
    "    else:\n",
    "        # Import OCI.\n",
    "        try:\n",
    "            import oci\n",
    "        except:\n",
    "            raise Exception(\n",
    "                \"You need to install the OCI python library to test locally\"\n",
    "            )\n",
    "        # Use defaults for anything unset.\n",
    "        if file_location is None:\n",
    "            file_location = oci.config.DEFAULT_LOCATION\n",
    "        if profile_name is None:\n",
    "            profile_name = oci.config.DEFAULT_PROFILE\n",
    "\n",
    "        # Load the config file.\n",
    "        try:\n",
    "            oci_config = oci.config.from_file(\n",
    "                file_location=file_location, profile_name=profile_name\n",
    "            )\n",
    "        except Exception as e:\n",
    "            print(\"You need to set up your OCI config properly to run locally\")\n",
    "            raise e\n",
    "        conf = SparkConf()\n",
    "        conf.set(\"fs.oci.client.auth.tenantId\", oci_config[\"tenancy\"])\n",
    "        conf.set(\"fs.oci.client.auth.userId\", oci_config[\"user\"])\n",
    "        conf.set(\"fs.oci.client.auth.fingerprint\", oci_config[\"fingerprint\"])\n",
    "        conf.set(\"fs.oci.client.auth.pemfilepath\", oci_config[\"key_file\"])\n",
    "        conf.set(\n",
    "            \"fs.oci.client.hostname\",\n",
    "            \"https://objectstorage.\\{0\\}.oraclecloud.com\".format(oci_config[\"region\"]),\n",
    "        )\n",
    "        spark_builder = SparkSession.builder.appName(app_name).config(conf=conf)\n",
    "\n",
    "    # Add in extra configuration.\n",
    "    for key, val in spark_config.items():\n",
    "        spark_builder.config(key, val)\n",
    "\n",
    "    # Create the Spark session.\n",
    "    session = spark_builder.getOrCreate()\n",
    "    return session\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"dataset\"></a>\n",
    "## 2. Generate the Dataset\n",
    "\n",
    "In this section, you will generate a synthetic credit card transaction dataset, using the project at [https://github.com/namebrandon/Sparkov_Data_Generation](https://github.com/namebrandon/Sparkov_Data_Generation)\n",
    "\n",
    "\n",
    "- Go to the Launcher, open a Terminal window and perform the following tasks:\n",
    "\n",
    "- Clone the data generation repository:\n",
    "\n",
    "    ```bash\n",
    "    git clone https://github.com/namebrandon/Sparkov_Data_Generation\n",
    "    ```\n",
    "\n",
    "\n",
    "- Get into the `Sparkov_Data_Generation` folder and install the requirements:\n",
    "\n",
    "    ```bash\n",
    "    cd Sparkov_Data_Generation\n",
    "    pip install -r requirements.txt\n",
    "    ```\n",
    "\n",
    "\n",
    "- Generate a small training dataset with 100 customers and transactions over 2 years:\n",
    "\n",
    "    ```bash\n",
    "    python datagen.py -n 100 -o \"data/training set/small\" 01-01-2012 12-31-2013\n",
    "    ```\n",
    "\n",
    "\n",
    "- Generate a medium training dataset with 1000 customers and transactions over 2 years:\n",
    "\n",
    "    ```bash\n",
    "    python datagen.py -n 1000 -o \"data/training set/medium\" 01-01-2012 12-31-2013\n",
    "    ```\n",
    "\n",
    "\n",
    "- Generate a medium scoring dataset with 1000 customers and transactions over 2 years:\n",
    "\n",
    "    ```bash\n",
    "    python datagen.py -n 1000 -o \"data/scoring set/medium\" 01-01-2012 12-31-2013\n",
    "    ```\n",
    "\n",
    "\n",
    "- To generate a very large training dataset of ~1.5TB and ~5.5B records, to use as a realistic out-of-memory training set with the Data Flow application, use the settings below.\n",
    "\n",
    "    Note: this will take a minimum of 2h on the largest shape VM available, and requires that you have selected at least 2000GB of storage when provisioning the notebook session. You can skip this step and run the notebook with the medium dataset but will get the best-performing model only when training with the very large dataset.\n",
    "\n",
    "    ```bash\n",
    "    python datagen.py -n 250000 -o \"data/training set/xlarge\" 01-01-2000 12-31-2020\n",
    "    ```\n",
    "\n",
    "The data generated is located in the data folder of the Sparkov_Data_Generation project.\n",
    "\n",
    "The file pattern insures all csv files named after the profiles are picked up, excluding the 'customers.csv'. Data files include *male*.csv and *female*.csv so *male*.csv covers both. In this notebook, the medium dataset is used for exploration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_folder = os.path.join(os.path.expanduser(home_folder), 'Sparkov_Data_Generation/data/')\n",
    "file_pattern = 'training set/medium/*male*.csv'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"store_data\"></a>\n",
    "## 3. Store Dataset on Object Storage\n",
    "\n",
    "The Data Flow applications cannot access the local storage on the Data Science notebook, so the data needs to be moved to Object Storage.\n",
    "\n",
    "The helper function in the following cell moves the local files to the data Object Storage bucket defined in setup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def store_on_oss(tenancy_namespace, bucket_name, data_folder, file_pattern):\n",
    "    if is_in_oci():\n",
    "        signer = oci.auth.signers.get_resource_principals_signer()\n",
    "        object_storage_client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)\n",
    "    else:\n",
    "        config = oci.config.from_file()\n",
    "        object_storage_client = oci.object_storage.ObjectStorageClient(config)\n",
    "\n",
    "    files = glob(data_folder + file_pattern)\n",
    "    file_count = len(files)\n",
    "    for i, file in enumerate(files):\n",
    "        print(f'{i + 1}/{file_count} copy: {file}')\n",
    "        filename = file.replace(data_folder, '')\n",
    "        print(f'{i + 1}/{file_count} to: {bucket_name}@{tenancy_namespace}/{filename}')\n",
    "        with open(file, 'r') as f:\n",
    "            put_object_response = object_storage_client.put_object(\n",
    "                namespace_name=tenancy_namespace,\n",
    "                bucket_name=bucket_name,\n",
    "                object_name=filename,\n",
    "                put_object_body=f\n",
    "            )\n",
    "        # sign in every so often because the auth has a timeout\n",
    "        if i == 100:\n",
    "            signer = oci.auth.signers.get_resource_principals_signer()\n",
    "            object_storage_client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run the function for the various datasets\n",
    "file_pattern_to_store = 'training set/medium/*male*.csv'\n",
    "store_on_oss(tenancy_namespace, data_bucket_name, data_folder, file_pattern_to_store)\n",
    "\n",
    "file_pattern_to_store = 'training set/small/*male*.csv'\n",
    "store_on_oss(tenancy_namespace, data_bucket_name, data_folder, file_pattern_to_store)\n",
    "\n",
    "file_pattern_to_store = 'scoring set/medium/*male*.csv'\n",
    "store_on_oss(tenancy_namespace, data_bucket_name, data_folder, file_pattern_to_store)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"explore\"></a>\n",
    "## 4. Explore the Dataset\n",
    "\n",
    "You will load the dataset and sample a subset for exploration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties\n",
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "sc = get_spark_session(app_name=\"CC_Fraud_Detection\")\n",
    "\n",
    "sc.conf.set(\"spark.sql.legacy.timeParserPolicy\", \"LEGACY\")\n",
    "sc.conf.set(\"spark.sql.debug.maxToStringFields\", 1000)\n",
    "df = sc.read.option(\"delimiter\", \"|\").csv(data_folder + file_pattern, header=True, inferSchema=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have a look at the schema with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- ssn: string (nullable = true)\n",
      " |-- cc_num: long (nullable = true)\n",
      " |-- first: string (nullable = true)\n",
      " |-- last: string (nullable = true)\n",
      " |-- gender: string (nullable = true)\n",
      " |-- street: string (nullable = true)\n",
      " |-- city: string (nullable = true)\n",
      " |-- state: string (nullable = true)\n",
      " |-- zip: integer (nullable = true)\n",
      " |-- lat: double (nullable = true)\n",
      " |-- long: double (nullable = true)\n",
      " |-- city_pop: integer (nullable = true)\n",
      " |-- job: string (nullable = true)\n",
      " |-- dob: string (nullable = true)\n",
      " |-- acct_num: long (nullable = true)\n",
      " |-- profile: string (nullable = true)\n",
      " |-- trans_num: string (nullable = true)\n",
      " |-- trans_date: string (nullable = true)\n",
      " |-- trans_time: string (nullable = true)\n",
      " |-- unix_time: integer (nullable = true)\n",
      " |-- category: string (nullable = true)\n",
      " |-- amt: double (nullable = true)\n",
      " |-- is_fraud: integer (nullable = true)\n",
      " |-- merchant: string (nullable = true)\n",
      " |-- merch_lat: double (nullable = true)\n",
      " |-- merch_long: double (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and get a sense of the distribution of the data with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1757067"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check the ratio of fraudulent vs. legitimate transactions with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-------+\n",
      "|is_fraud|  count|\n",
      "+--------+-------+\n",
      "|       1|   9508|\n",
      "|       0|1747559|\n",
      "+--------+-------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.groupBy('is_fraud').count().show(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Down-sampling the dataset will make it easier to run local exploration tasks. Here the dataset is down-sampled to 5% of the original 1.6M+ rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sample = df.sample(False, 0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check that the new row count is much smaller:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88024"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_sample.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-----+\n",
      "|is_fraud|count|\n",
      "+--------+-----+\n",
      "|       1|  494|\n",
      "|       0|87530|\n",
      "+--------+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_sample.groupBy('is_fraud').count().show(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"customer_info\"></a>\n",
    "### 4.1. Customer Information\n",
    "\n",
    "The first 16 columns correspond to the customer profile:\n",
    "- ssn: string (nullable = true)\n",
    "- cc_num: long (nullable = true)\n",
    "- first: string (nullable = true)\n",
    "- last: string (nullable = true)\n",
    "- gender: string (nullable = true)\n",
    "- street: string (nullable = true)\n",
    "- city: string (nullable = true)\n",
    "- state: string (nullable = true)\n",
    "- zip: integer (nullable = true)\n",
    "- lat: double (nullable = true)\n",
    "- long: double (nullable = true)\n",
    "- city_pop: integer (nullable = true)\n",
    "- job: string (nullable = true)\n",
    "- dob: string (nullable = true)\n",
    "- acct_num: long (nullable = true)\n",
    "- profile: string (nullable = true)\n",
    "\n",
    "Looking at how the data is generated, we can see that any customer may have fraudulent transactions, so that `ssn`, `acct_num`, `name`, or `job` may not be relevant.\n",
    "\n",
    "Each customer has a specific profile, which determines the type, amount, and frequency of transactions. The profiles consider `gender`, `age`, and type of city (urban or rural), so gender, age, and city details are relevant columns.\n",
    "\n",
    "In each profile, there is also a flag determining if the customer travels or not. Note that at the time of writing (v1.0) the generator code does not take this flag into account)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"age\"></a>\n",
    "#### 4.1.1. Customer Age\n",
    "\n",
    "Let's have a look at the customer attributes, starting with age:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Fraud vs. Legitimate'}, ylabel='Frequency'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample\\\n",
    "    .withColumn('age',floor(datediff(col('trans_date'), to_date(col('dob'), 'yyyy-mm-dd'))/365.25))\\\n",
    "    .withColumn('fraud', when(col('is_fraud') == 1, col('age')).when(col('is_fraud') == 0, None))\\\n",
    "    .withColumn('legitimate', when(col('is_fraud') == 0, col('age')).when(col('is_fraud') == 0, None))\\\n",
    "    .select(['fraud', 'legitimate'])\\\n",
    "    .toPandas().plot.hist(by=['fraud', 'legitimate'], histtype='bar', bins=100, title='Fraud vs. Legitimate', xlabel='Age', secondary_y='fraud')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Customer age distribution between fraudulent and non fraudulent transactions is visually different indicating age is a relevant factor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"gender\"></a>\n",
    "#### 4.1.2. Customer Gender\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'legitimate'}, ylabel='count'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample.filter(col('is_fraud') == 1)\\\n",
    "    .withColumn('gender',when((col('gender') == 'M'),'Male').when((col('gender') == 'F'),'Female'))\\\n",
    "    .select('gender')\\\n",
    "    .groupBy('gender')\\\n",
    "    .count()\\\n",
    "    .toPandas().set_index('gender').plot.pie(y='count', title='fraud', legend=None)\n",
    "\n",
    "df_sample.filter(col('is_fraud') == 0)\\\n",
    "    .withColumn('gender',when((col('gender') == 'M'),'Male').when((col('gender') == 'F'),'Female'))\\\n",
    "    .select('gender')\\\n",
    "    .groupBy('gender')\\\n",
    "    .count()\\\n",
    "    .toPandas().set_index('gender').plot.pie(y='count', title='legitimate', legend=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataset is fairly balanced in terms of gender distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"city_population\"></a>\n",
    "#### 4.1.3. Customer City Population\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Fraud vs. Legitimate'}, ylabel='Frequency'>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample\\\n",
    "    .withColumn('fraud', when(col('is_fraud') == 1, col('city_pop')).when(col('is_fraud') == 0, 0))\\\n",
    "    .withColumn('legitimate', when(col('is_fraud') == 0, col('city_pop')).when(col('is_fraud') == 0, 0))\\\n",
    "    .select(['fraud', 'legitimate'])\\\n",
    "    .toPandas().plot.hist(by=['fraud', 'legitimate'], histtype='bar', bins=100, logy=True, title='Fraud vs. Legitimate', xlabel='Population', secondary_y='fraud')\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generator creates profiles based on urban or rural areas, yet the population distribution seems similar with both fraud and legitimate transactions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"transaction_info\"></a>\n",
    "### 4.2. Transaction Information\n",
    "\n",
    "The next 10 columns cover the transaction information, including the label `is_fraud`:\n",
    "- trans_num: string (nullable = true)\n",
    "- trans_date: string (nullable = true)\n",
    "- trans_time: string (nullable = true)\n",
    "- unix_time: integer (nullable = true)\n",
    "- category: string (nullable = true)\n",
    "- amt: double (nullable = true)\n",
    "- is_fraud: integer (nullable = true)\n",
    "- merchant: string (nullable = true)\n",
    "- merch_lat: double (nullable = true)\n",
    "- merch_long: double (nullable = true)\n",
    "\n",
    "Let's have a look at the transaction columns to see what may be relevant:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"day_of_week\"></a>\n",
    "#### 4.2.1. Day of Week\n",
    "\n",
    "First, let's look for patterns of fraudulent transactions vs. legitimate ones in the transaction date:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Legitimate'}, xlabel='Day of the Week'>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample.filter(col('is_fraud') == 1)\\\n",
    "    .withColumn('day_of_week', dayofweek(col('trans_date')))\\\n",
    "    .select('day_of_week')\\\n",
    "    .groupBy('day_of_week')\\\n",
    "    .count()\\\n",
    "    .sort('day_of_week')\\\n",
    "    .toPandas().plot.bar(y='count', x='day_of_week', title='Fraud', xlabel='Day of the Week')\n",
    "\n",
    "df_sample.filter(col('is_fraud') == 0)\\\n",
    "    .withColumn('day_of_week', dayofweek(col('trans_date')))\\\n",
    "    .select('day_of_week')\\\n",
    "    .groupBy('day_of_week')\\\n",
    "    .count()\\\n",
    "    .sort('day_of_week')\\\n",
    "    .toPandas().plot.bar(y='count', x='day_of_week', title='Legitimate', xlabel='Day of the Week')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day of the week seem to have some relevance although it may just be our sample."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"weekend\"></a>\n",
    "#### 4.2.2. Weekend or Weekday\n",
    "\n",
    "Let's now look if fraud is more prevalent on weekend or weekdays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Legitimate'}, ylabel='count'>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPUAAAD3CAYAAADFeRJuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAaKUlEQVR4nO3de5QU5ZnH8e8zw3ATEAkIgq0YIooMiqKiqEiMl3gFUWPuarzFJBrFdHKS3U2lgtlkMxovSU42m2xiVuNZV02Ml42g0QAKq0RFaFQEA2bEG4Igd5iZZ/94a2JD5tI9011vV/XzOaePMz09Xb/B+c1b1V31vqKqGGPSo8Z3AGNMaVmpjUkZK7UxKWOlNiZlrNTGpIyV2piUsVKbLhOR20XkBt85zK6s1CkhIqtEZKuIbMq7Dfedy8TPSp0uZ6tqv7zbG61fEJEePoOZ+FipU0xEVES+LCLLgeXRfbeKSKOIvC8iz4rICXmP32V3WkSmiMjreZ8fLiLPichGEbkb6B3nz2MKY6VOv2nAROCQ6POFwHhgEHAXcI+IdFpOEekJ3A/cEX3vPcB5JU9rus1KnS73i8j66HZ/dN/3VXWdqm4FUNU7VXWtqjap6k1AL+CgAp77GKAOuEVVd6rqvbg/EKbC2HFWukxT1cdaPxERBRrzHyAiXwMuBYYDCgwABhfw3MOB1brrFUCvdTuxKTkbqdPv7yWMjp+/DnwC2EtVBwIbAIkeshnom/e9w/I+fhMYISKSd99+5QhsusdKXV36A03AGqCHiHwbN1K3WgScISKDRGQYcG3e1xZE33uNiNSJyHTg6FhSm6JYqavLLOAR4BXcrvM2dt09vwN4AVgFzAbubv2Cqu4ApgMXA+uAC4HfxZDZFElskgRj0sVGamNSxkptTMpYqY1JGSu1MSljpTYmZazUxqSMldqYlLFSG5MyVmpjUsZKbUzKWKmNSRkrtTEpY6U2JmWs1MakjJXamJSxUhuTMlZqY1LGSm1MylipjUkZK7UxKWOlNiZlrNTGpIyV2piUSVSpReRmEbk27/NZIvLLvM9vEpEZRT7n7SJyfiePmSIiDxUd2BgPElVq4ClgEoCI1OAWdhub9/VJwHwPuYypGEkr9Xzg2OjjsUAO2Cgie4lIL2AMoCIyJ1pQfZaI7AMgIqNE5JHo/nkicvDuTy4iM6ORu1ZEPi4iL4vIc7jlZlofc7SILBCR50VkvogcFN0/V0TG5z3uSRE5rFz/EMa0J3HL7ojISuBE4HTcao0jcIu3bQBuxK3yOFVV14jIhcBpqvoFEfkT8EVVXS4iE3HrNp8kIrcDD+EWZu8PXIVbs3k5cBKwAremVF9VPUtEBgBbVLVJRE4GrlLV80TkIuBwVb1WREYDd6nqkTH9s+xCwrAP8BHgQ3m3QW183PrfXsB2YCtufa1twBbgPWBtdHs3+u/fgMUaBKvj+4lMMZJY6t8CD+JK/SNcqSfhSj0ROBX4a/TwWtwSrNNxKz0uy3uqXqo6Jir14cDTqnpFtI3xwG2qOjn6/BzgiqjUGeA24EDcH5A6VT1YRPoCi3F7CzOB11X1J2X5R8gjYdgbGA9MAI6MbmNwP3s5vYv7eV/Iu72oQbCjzNs1nUjiovOtx9XjcLvfjcD1wPvAn4ERqnps/jdEo+t6VR3fznMuBCaIyCBVXdfJ9mcCT6jquSIyMtomqrpFRB4FpuLWf55Q9E/WCQnDXsBhuOK2lvgQ/Px/HIzbkzkp774mCcOX+aDkj2sQPOshW1VLYqnnA18D/qqqzcA6ERmIO8a+ErhaRI5V1QUiUgeMVtWlIrJSRC5Q1XuihdMPVdUXoud8BLfM68MicirwMjBSREap6qvAp/K2vyfQuut58W7Zfonbi5inqu+V4oeVMOwHnIP7Q3Ea0LsUz1smPYD66PYZAAnD14D7gd8DT2oQNHtLVyWSWOoluFHirt3u66eq70RvT90mInvifr5bgKW4X7Kficg/A3XAf+NGEwCisvcHHgDOAK7AlXwLMA93vA3wQ+A30fM8nB9MVZ8VkfeBX3fnB5Qw3AM4C7cG9OlUdpE7sz/w1ej2roThA7iCP6pBsN1rspRK3DF1JROR4bjd8YNVtaWo7w3DvsCZuBH5DKBvyQNWlk3AH3EFf0iDYKPnPKlhpS4REfk88D1ghqreU/D3heFJuL2Cs4A9yhSv0m0EfgHcrEHwuu8wSWel9kDCsBa4AMgCR3iOU0l24g6rGjQIlvoOk1RW6hhF7x9fBlwHHOA5TiVT4H+Bf9MgmOc7TNJYqWMQvRV1JfBNYJjnOEmzAGgA7tcgsF/WAlipy0jCsA64FPgnYF/PcZJuGe41izut3B2zUpeJhOE5wK3ASM9R0mY+8GUNgkW+g1QqK3WJSRgOAX6Me4/ZlEcz8O/AP2sQrPecpeJYqUtIwvDTuNF5sO8sVWINMEOD4E7fQSqJlboEJAyH40aOs31nqVIPA1falWNO0q6nrjgShpcBL2KF9ulMYGn0/6Lq2UjdRRKGB+DOgvqY7yxmF7OBT2sQrPUdxBcrdRdIGH4O+BnVe1pnpVsJTNUgWOI7iA9W6iJIGArueup/8p3FdGoT8HkNgt/7DhI3K3WBohlGfoO7isokgwLfAWZW0wkrVuoCSBjuDfwBOMZ3FtMl9wIXaRBs8R0kDlbqTkgYjsVNTDjScxTTPYtwx9l/8x2k3OwtrQ5IGJ6GOy1xpOcopvvGAwslDI/3HaTcrNTtkDD8Eu6khgG+s5iS2Rt4XMIw1afwWqnbIGH4A+CnlH+aXRO/OuBOCcPUnixkx9S7kTD8JvCvvnOYstsGnKlB8LjvIKVmpc4jYXgpbppfUx02A6doECzwHaSUrNQRCcNpuLc+bJe7uqwHPpqm67Ot1ICE4Ym4Cf2TPL+26bo1wGQNgpd9BymFqi+1hOF4YA72Kne1ex04QYNgle8g3VXVpZYwHIVbm2uo7yymIryKK/abvoN0R9WWWsJwGK7QH/adxVSUJcAxST6ltCrfp46WuPkjVmjzj8bhpqRKrKosNW5iwPG+Q5iKdZmEYWKvxqu63W8Jw0+x64qZxrRlA3C4BsFK30GKVVWljl4Ye54PlqU1piNP41442+k7SDGqZvdbwrAncDdWaFO4icANvkMUq2pKDYTABN8hTOJkJQxP9R2iGFWx+y1hOBH39pWdAmq64m3gMA2Ct30HKUTqR+pobrHbsUKbrhsK3BFNPFnxUl9q3DHRwb5DmMQ7BfiS7xCFSPXud7TbPZ/q+ONlym8dcKAGwTrfQTqS9l/2BtL/M5r4DMLN+17RUjtSSxiegZtjzJhSagaO0CBY7DtIe1I5ikUvaNiURKYcaqnwc8NTWWrgk8BhvkOY1JoiYXiW7xDtSd3ut4RhHfASMMp3FpNqi4HxlbicTxpH6suwQpvyOxT4lO8QbUnVSB1dJ70C2Md3FlMVXgUO1iBo8h0kX9pG6muwQpv4jAIu9R1id6kptYThXsA3fOcwVec63wF2l5pSA18BBvoOYarOQdEU0xUjFaWO3pe+xHcOU7Uu9x0gXypKDZwIHOA7hKla50kYDvIdolVaSn2x7wCmqvUGPu87RKvEl1rCsB9wvu8cpupVzC544ksNfALYw3cIU/UOkTA83ncISEepL/YdwJjIFb4DQMLPKIum/F3hO4cxkW3AcA2C93yGSPpIfbHvAMbk6Q18zneIxJZawrAGuMh3DmN2c4HvAIktNTAZyPgOYcxuJkoYen3hNsml/pjvAMa0oQ44wWeAJJfa6z+cMR04yefGE1nqaF2sib5zGNMOK3UXHIV7pdGYSnS4hOFAXxtPaqlt19tUshpgis+NJ5GV2lQ6b7vgiSt19P70cb5zGNMJK3URxgF7+g5hTCfGShgO9bHhJJZ6su8AxhRoio+NJrHUdjxtkuIgHxtNYqmP9B3AmAJ5mWIrUaWWMOwB7Oc7hzEFslIXYD/cqoPGJMFIHxtNWqltxlCTJPtGe5exKqjUIvKnQu6LgZXaJEktHi4P7vCviIj0BvoCg0VkL0CiLw0ARpQ5W1us1CZpDgBWxrnBznYNrgSuBYYDz/JBqd8HflK+WO2yxe9M0oyMe4MdllpVbwVuFZGrVfXHMWXqiJczdIzphtj3Lgs6iFfVH4vIJNxfnR559/9XmXK1Z++Yt2dMd1VmqUXkDtxavIuA5uhuBazUxnQs9vMqCn25/UjgEPU/SbiV2iRNn7g3WOj71DlgWDmDdEbCsA6b7cQkT8+4N1joSD0YeFFEngG2t96pqueUJVXbmmLcljGlUhf3Bgst9XfKGaIQGgQqYdiMnSZqkqUyR2pVnVPuIAXaiZXaJEtljtQishH3aje4vzx1wGZVHVCuYO2wXfAyOGPxkXNPXDau3neONGoR3UgQ7zYLHan7t34sIgJMBY4pV6gO7PSwzVQ78O3hS05cNu5YQWIfUapBrcrGuLdZ9FVa6twPnFb6OJ2yUpdQ/6191lw679QhVuiyau78IaVV6O739LxPa3DvW28rS6KO2e53idS0SNP1s6e/UaM1h/nOknKx96TQV7/Pzvu4CViF2wWPm43UJXL53I/P77ujl03iWH7r4t5gocfUl5Q7SIGs1CVw4svjnhq1Zh8rdDxiL3WhkyTsKyK/F5F3ott9IrJvucO1wUrdTZm1Q5adseTIw33nqCKVWWrg18ADuOuqhwMPRvfFbb2HbaZGn+0913/piTP6CNLXd5YqUrGlHqKqv1bVpuh2OzCkjLnas8LDNlNBlJbrZ09fUau1NhtrvCq21GtF5LMiUhvdPgusLWewdiz3sM1U+NyCk+YN2NbX5kyP39txb7DQUn8B+ATwFvAmcD5wcZkydeQVD9tMvKNWjn5m7Or97YUxP2Lfuyz0La3vAhep6nsAIjIIuBFX9jjZSF2kvTcMXHX+X447SBDp/NGmDGIvdaEj9aGthQZQ1XWAj1dQrdRF6NnUY/NXHzunSRBbJdSPrcDquDdaaKlroimCgb+P1LFPUq5BsBF3CGAK8NVHpy6ua+nxEd85qtir2Vwm9tmCCi3mTcACEbkn+vwC4HvlidSp5XiehSUJzvvLcXOGbNrzRN85qpyXd2sKGqmjWUOn417JexuYrqp3lDNYB2wXvBNjV+/3/NErRx/vO4fhJR8bLXgXWlVfBF4sY5ZC2SvgHdhrc783Pjf/YxlBbDIJ/57xsdGkLZAHNlK3q7a5Zvt1s6etr0EG+85iAHjax0aTWGovf/2S4MuPn/VM76aeh/jOYQBozOYyb/rYcOJKrUHwOpVxGFBRTltyxLx91w8+wXcO83feBp/ElToyy3eASjLqnWFLT3r5sKN95zC78LLrDVbqxOu3rc+ay+d+fJAgvXxnMbuY52vDSS31XPxMp1RRpEWar5917uoarbElfivLWmz3uzgaBFtxxa5ql8479ck9dvQe7zuH+QezsrlMi6+NJ7LUkareBT/+lbHzR78zws4Yq0x/9LlxK3UCjVj3oeVnv3C0zQJamVqAR3wGSGypNQiWAq/7zhG33jt6bvjy42f1FGQP31lMm/6SzWXe9RkgsaWOzPYdIFaKzpg97ZUeWru/7yimXff6DpD0Uv+v7wBx+vTTU+YO3NrvKN85TLtagLt8h0h6qR/Cz1xpsTti1aiFhzUeYGeMVbbHs7lM7JMi7C7RpdYg2A74ugQ0NkPe3/O1CxdOPlCQRP//qgL/5TsAJLzUkV/4DlBOdU21W7762NTtggz0ncV0aDPwO98hIAWl1iB4EZjvO0e5XPPY1Od7NvcY7TuH6dR92Vxms+8QkIJSR/7Dd4BymPbcMXOHbhx4nO8cpiA/8R2gVVpKfTfwju8QpTTmjcwLx746ZpLvHKYgT2ZzmYW+Q7RKRak1CLYBP/Odo1QGbtnjzYueOnm4ILHP2Gq65Ee+A+RLRakjPyUFV27VNtfsuG72uWtrEB9rlZnivQr8wXeIfKkptQbBGuBO3zm664t/PuPpPjt71vvOYQp2i88rstqSmlJHbgZinzy9VE5eOv7J/dftbSeYJMc7+FnSuUOpKnX09tZvfOfoipFrhr50youH26qUyXJDpbyNlS9VpY58E9joO0Qx9tjWe+2Vc04fIEhv31lMwVYCP/cdoi2pK7UGwVv4WxKoaNIizTNmn/tardaM8J3FFOXb2Vxmh+8QbUldqSO34F6VrHiXPHXyk/239znCdw5TlMVUwNVY7UllqaMLPb7mO0dnJq0Ys+DgtzI2JVHyfLPSXvHOl8pSA2gQ3A885jtHe/ZZP+jVqc8fM853DlO0B7O5TEVfx5/aUkeuBZp9h9hdr51171/9p7NrBOnnO4spyhbgGt8hOpPqUkfzmP277xy7UPS62dNe6tFSe4DvKKZoM7O5zCrfITqT6lJHvg2s8x2i1YULJ88dtKX/RN85TNGeB270HaIQqS+1BsE64HrfOQAO+9sBzx7x2ig7Yyx5moDLsrlMk+8ghUh9qQE0CG4HbveZ4UOb+r/+6aenfNimJEqk72Rzmed8hyhUNf2CfQlY4mPDdU21W6+dPW2TIHv52L7plieA7/sOUYyqKXW0/tYFeDiF9CuPn/1sr+a6g+Perum2d4HPVvJ70m2pmlIDaBAsAy6Pc5tnLTp67j4bBh0f5zZNyVySzWXe8B2iWFVVagANgrtxEyqU3ei3Riw+YfnYY+PYlim5W7O5zEO+Q3RF1ZU6MgMo65xSA7b2fecL804ZKkhdObdjyuIxEnCacXuqstQaBDuATwDvleP5a1pk54xZ575VQ83Qcjy/KatlwAVJefuqLVVZagANglXARZRhppQr5py+oO/OXoeW+nlN2a0DzsrmMut9B+mOqi01gAbBg7jzw0vmoy8d+tSH3x02uZTPaWKxE5iezWVW+A7SXVVdagANgtso0fHTfmuHLPt4boJdG508ijtjbI7vIKVQ9aUG0CC4CTcNUpf13d7rvaueOLOvIH1KFMvE56psLlMRi9uVgpU6okHwA+BfuvK9orTMmH3uq7VakylxLFN+12ZzmYqca6yrrNR5NAhuAL5b7Pd9fv7H5g7Y1tdmAk2eb2RzmVt9hyg1K/VuNAgCijjX9+i/jn76kDf2symJkufb2Vzmh75DlIOVug0aBN8CGjp73NANA1ee9+xxYwSRGGKZ0mgBrs7mMjN9BykXK3U7NAi+jlvxo009d/bYdM1j57QIMiDGWKZ7tgMXZnOZill2thys1B3QIJiBO6X0H+Y5u/bRaUvqWnqMij+V6aINwGnZXOZe30HKzUrdCQ2Cm4EzgfWt952/8Pg5gzcPsAs1kmM1cEJa3ofujJW6ABoEs4BjgFfqX9//uaNWHWiXUibHHGBCNpfxMkGGD1bqAkXXYk/85DOTlwtS6zuPKciNwMnZXOZt30HiJKqJXfnVi4b6RgG+hXs/2/4oVqaNuAkO7vMdxAcrdRc11DdOwU1muL/fJGY3LwCfzOYyL/sO4ouNNF2UzWX+DIwD/tNzFOM0ATOBo6q50GAjdUk01DeeCfwC2Md3liqVAy5K0jS+5WQjdQlkc5mHgXrgt76zVJlm3Cm9E6zQH7CRusQa6htPAG4DxnuOknaPAddlc5mc7yCVxkpdBg31jTXAZcD3gMGe46TNCuBr2VzmD76DVCordRk11DcOBL4DXAX09Bom+d4HbsBN3bvDd5hKZqWOQUN9477AN3ALCfTyHCdpNgI/AW7K5jJrfYdJAit1jBrqG4cDXweuAGzao469h1t04RYrc3Gs1B401DcOBa4BLgVsbvBdrcKNzD/P5jKbPGdJJCu1Rw31jXXAdNwxdzXPntIEPAj8HHg0aQvSVRordYVoqG8cA3wR+CSwt+c4cVkF/BL4VTaXedNzltSwUleYhvrGWmAycD5uFB/mN1HJrQDuA34HLMzmMkX9AorIzcBrqnpL9PksoFFVL4s+vwlYrao/KuI5bwceUtWSTaAgIiOj56wv1XMWqkfcGzQdy+YyzbiFzp9oqG+8GjgOOA84GRjrM1sXteAusngAuK8E1zU/hVsH7RYRqcGdB5A/pdQk4LpubiPRrNQVLDq2nBfdaKhv3BuYAnw0uh3kLVz7moHngLm4CQrmlXhtqvl8MHfcWNx53/uIyF7AFmAMoCIyB+iHWzj+YlV9U0RG4V5RHxI99nJV3eXiDxGZCWRwL2LOwP0B6QX8XlWDaAT+I/Ak7g/IamCqqm4VkQnAr6Knml3Cn7kotvudYA31jcNwp6Memnc7GIhr+dzNwFJcsZZEt2eyuczGcm5URFbiXlg8HRBgBLAANw/ZjbhldKaq6hoRuRA4TVW/ICJ/Ar6oqstFZCLwfVU9qXX3G5gI9Me9cHkK7hDoymgbDwA/BP6GO4Q4UlUXicj/AA+o6p0ishj4iqrOFZEG4HTb/TZFyeYybwGPRDcAGuobe+JG8JG4a733w109tg/u+Lwf0De69eEfL+ppArZFt63AGuAN3Ij0Rt7Hy4CVxR4Tl8h83Cg5CfgRrtSTcKVeDZwKPCpu5uZa4E0R6Rc95h75YEbn/BOB/gV4WlWvABCRU6PneT76ej/gQFypV6rqouj+Z4GRIjIQGKiqc6P778D90YmdlTplolMoW0fNTjXUN/bClbsJ2Bod01e6p3AFHYfbS2gErsedSvpnYISq7jIxpIgMANar6vh2nnMhMEFEBqnqOtzo/H1V3WVJnmj3e3veXc1U2IlEVuoql81ltrPrL2kSzMetVPpXVW0G1kUj5Vjc7vLVInKsqi4QkTpgtKouFZGVInKBqt4jbrg+VFVfiJ7zEWAW8HA0Ss8CZorIb1V1k4iMwC132yZVXS8i60XkeFV9EvhMuX74ztj11CaJluBe9f6/3e7boKrv4I6F/01EXgAW4UZ1cEW7NLp/KTA1/0lV9R7cZBcP4F6cvAtYICJLgHtxx9sduQT4qYgswo30XtgLZcakjI3UxqSMldqYlLFSG5MyVmpjUsZKbUzKWKmNSRkrtTEpY6U2JmWs1MakjJXamJSxUhuTMlZqY1LGSm1MylipjUkZK7UxKWOlNiZlrNTGpIyV2piUsVIbkzJWamNSxkptTMpYqY1JGSu1MSljpTYmZazUxqTM/wPOdEh/gzTzdQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample.filter(col('is_fraud') == 1)\\\n",
    "    .withColumn('is_weekend', when(dayofweek(col(\"trans_date\")).isin([1,7]), 'Weekend').otherwise('Weekday'))\\\n",
    "    .select('is_weekend')\\\n",
    "    .groupBy('is_weekend')\\\n",
    "    .count()\\\n",
    "    .toPandas().set_index('is_weekend').plot.pie(y='count', title='Fraud', legend=None)\n",
    "df_sample.filter(col('is_fraud') == 0)\\\n",
    "    .withColumn('is_weekend', when(dayofweek(col(\"trans_date\")).isin([1,7]), 'Weekend').otherwise('Weekday'))\\\n",
    "    .select('is_weekend')\\\n",
    "    .groupBy('is_weekend')\\\n",
    "    .count()\\\n",
    "    .toPandas().set_index('is_weekend').plot.pie(y='count', title='Legitimate', legend=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a significant skew towards fraudulent transactions on weekends."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"month_of_year\"></a>\n",
    "#### 1.4.2.3. Month of the Year\n",
    "\n",
    "Let's now look at the month of the year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'legitimate'}, xlabel='Month of the Year'>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample.filter(col('is_fraud') == 1)\\\n",
    "    .withColumn('month_of_year', month(col('trans_date')))\\\n",
    "    .select('month_of_year')\\\n",
    "    .groupBy('month_of_year')\\\n",
    "    .count()\\\n",
    "    .sort('month_of_year')\\\n",
    "    .toPandas().plot.bar(y='count', x='month_of_year', xlabel='Month of the Year', title='Fraud', legend=None)\n",
    "\n",
    "df_sample.filter(col('is_fraud') == 0)\\\n",
    "    .withColumn('month_of_year', month(col('trans_date')))\\\n",
    "    .select('month_of_year')\\\n",
    "    .groupBy('month_of_year')\\\n",
    "    .count()\\\n",
    "    .sort('month_of_year')\\\n",
    "    .toPandas().plot.bar(y='count', x='month_of_year', xlabel='Month of the Year', title='legitimate', legend=None)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The month of the year seems relevant as fraudulent transactions are fairly evenly distributed over the whole year while legitimate transaction peek in December."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"time_of_day\"></a>\n",
    "#### 4.2.4. Time of Day\n",
    "\n",
    "Now let's look at the time of day:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Legitimate'}, xlabel='Hour of the Day'>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample.filter(col('is_fraud') == 1)\\\n",
    "    .withColumn('hour_of_day', hour(col('trans_time')))\\\n",
    "    .select('hour_of_day')\\\n",
    "    .groupBy('hour_of_day')\\\n",
    "    .count()\\\n",
    "    .sort('hour_of_day')\\\n",
    "    .toPandas().plot.bar(y='count', x='hour_of_day', title='Fraud', legend=None, xlabel='Hour of the Day')\n",
    "\n",
    "df_sample.filter(col('is_fraud') == 0)\\\n",
    "    .withColumn('hour_of_day', hour(col('trans_time')))\\\n",
    "    .select('hour_of_day')\\\n",
    "    .groupBy('hour_of_day')\\\n",
    "    .count()\\\n",
    "    .sort('hour_of_day')\\\n",
    "    .toPandas().plot.bar(y='count', x='hour_of_day', title='Legitimate', legend=None, xlabel='Hour of the Day')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time of day is one of the factors that highlight fraudulent transactions. This is expected as the generator code specifically \n",
    "defines a higher probability of fraud during late evening and early morning hours."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"amount\"></a>\n",
    "#### 4.2.5. Transaction Amount\n",
    "\n",
    "Let's see what other columns may be relevant. The transaction amount distribution is expected to be a factor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Fraud vs. Legitimate'}, ylabel='Frequency'>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample\\\n",
    "    .withColumn('fraud', when(col('is_fraud') == 1, col('amt')).when(col('is_fraud') == 0, None))\\\n",
    "    .withColumn('legitimate', when(col('is_fraud') == 0, col('amt')).when(col('is_fraud') == 0, None))\\\n",
    "    .select(['fraud', 'legitimate'])\\\n",
    "    .toPandas().plot.hist(by=['fraud', 'legitimate'], histtype='bar', bins=100, logy=True, title='Fraud vs. Legitimate', xlabel='Amount', secondary_y='fraud')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Amount is clearly a factor in identifying fraudulent transactions, so this column will be kept."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"category\"></a>\n",
    "#### 4.2.6. Merchant Category\n",
    "\n",
    "Let's look at the merchant `category` column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'legitimate'}, xlabel='category'>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAFUCAYAAADf+HxmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAwyklEQVR4nO3dd5xdVbn/8c8XQhGkSqRjgIsiihQjgqAiWGhSFBAEQURA4UcRu4IB1OtFvaKAoBHEUKVIV5AiHSkJvUpAURAweCkBpOnz+2OtQ/ZMJpmy156Zs/N9v17zypw95zx7Z+acZ629qiICMzNrl7lG+gLMzKw8J3czsxZycjczayEndzOzFnJyNzNrISd3M7MWcnI3a4CkX0n6zkhfh825nNyt9ST9RdK/JD1X+VpmpK/LrElO7jan+GhEvL7y9ffODySNGckLM2uCk7vNkSSFpH0kPQA8kI/9RNLfJD0raYqk91ae36OZRdKGkh6pPF5L0i2Spks6HZh/OP8/Zr05uducbGvg3cBq+fHNwJrA4sCpwJmS+k3SkuYFzgVOyq89E/h48as1GwQnd5tTnCvp6fx1bj72vYj4v4j4F0BEnBwR/4yIVyPif4H5gLcMIPa6wDzAjyPilYg4i1RQmI0YtzXanGLriLis80BSAH+rPkHSl4DdgWWAABYGlhhA7GWAR6PnKnwP175isxpcc7c52WvJOLevfwXYHlgsIhYFngGUn/I8sEDltUtVvn8MWFaSKsdWaOKCzQbKyd0sWQh4FZgGjJH0LVLNveM2YDNJi0taCjig8rM/5tfuJ2keSR8D1hmWqzabBSd3s+T3wMXAn0hNKi/Ss9nmJOB24C/AJcDpnR9ExMvAx4BPA/8HfAI4exiu2WyW5M06zMzaxzV3M7MWcnI3M2shJ3czsxbqN7lL+qWkf0i6q3LsB5Luk3SHpHMkLVr52dclTZV0v6SPNHTdZmY2G/12qEp6H/AccGJEvD0f+zDwh4h4VdLhABHxVUmrAaeRhoEtA1wGvDki/j27cyyxxBIxbty4uv8XM7M5ypQpU56MiLF9/azfGaoRcbWkcb2OXVJ5eAOwbf5+K+DXEfES8GdJU0mJ/o+zO8e4ceOYPHlyf5diZmYVkmY5E7pEm/tngIvy98vSc2zwI/lYXxe1p6TJkiZPmzatwGWYmVlHreQu6ZukmXmnDPa1ETExIsZHxPixY/u8qzAzsyEa8sJhkj4NbAFsXFkw6VFg+crTlsvHzMxsGA2p5i5pE9IiS1tGxAuVH50P7CBpPkkrAqsAN9W/TDMzG4x+a+6STgM2BJbIO89MAL5OWuv60rwQ3g0R8bmIuFvSGcA9pOaaffobKWNmZuWNirVlxo8fHx4tY2Y2OJKmRMT4vn7mGapmZi3k5G5m1kJO7mZmLeQ9VG2WdOihg3p+TJjQ0JWY2WC55m5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQl7P3cy6jvca6J9r7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLdRvcpf0S0n/kHRX5djiki6V9ED+d7F8XJKOlDRV0h2S1m7y4s3MrG8Dqbn/Ctik17GvAZdHxCrA5fkxwKbAKvlrT+DYMpdpZmaD0W9yj4irgf/rdXgrYFL+fhKwdeX4iZHcACwqaelC12pmZgM01Db3JSPisfz948CS+ftlgb9VnvdIPjYTSXtKmixp8rRp04Z4GWZm1pfaHaoREUAM4XUTI2J8RIwfO3Zs3cswM7OKoSb3JzrNLfnff+TjjwLLV563XD5mZmbDaKjJ/Xxg1/z9rsB5leO75FEz6wLPVJpvzMxsmPS75K+k04ANgSUkPQJMAP4HOEPS7sDDwPb56b8DNgOmAi8AuzVwzWZm1o9+k3tE7DiLH23cx3MD2KfuRZmZWT2eoWpm1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQrWSu6QvSLpb0l2STpM0v6QVJd0oaaqk0yXNW+pizcxsYIac3CUtC+wHjI+ItwNzAzsAhwNHRMR/AU8Bu5e4UDMzG7i6zTJjgNdJGgMsADwGbASclX8+Cdi65jnMzGyQhpzcI+JR4IfAX0lJ/RlgCvB0RLyan/YIsGxfr5e0p6TJkiZPmzZtqJdhZmZ9qNMssxiwFbAisAywILDJQF8fERMjYnxEjB87duxQL8PMzPpQp1nmg8CfI2JaRLwCnA2sDyyam2kAlgMerXmNZmY2SHWS+1+BdSUtIEnAxsA9wBXAtvk5uwLn1btEMzMbrDpt7jeSOk5vAe7MsSYCXwUOlDQVeANwfIHrNDOzQRjT/1NmLSImABN6HX4IWKdOXDMzq8czVM3MWsjJ3cyshZzczcxaqFabu5k1Q4ceOqjnx4TeXV82p3PN3cyshZzczcxayMndzKyFnNzNzFrIyd3MrIWc3M3MWsjJ3cyshZzczcxayMndzKyFnNzNzFrIyd3MrIWc3M3MWsjJ3cyshZzczcxayMndzKyFnNzNzFrIyd3MrIWc3M3MWsjJ3cyshZzczcxayBtkm5n10oYNyl1zNzNrISd3M7MWqpXcJS0q6SxJ90m6V9J6khaXdKmkB/K/i5W6WDMzG5i6NfefABdHxKrAGsC9wNeAyyNiFeDy/NjMzIbRkJO7pEWA9wHHA0TEyxHxNLAVMCk/bRKwdb1LNDOzwapTc18RmAacIOlWScdJWhBYMiIey895HFiyrxdL2lPSZEmTp02bVuMyzMystzrJfQywNnBsRKwFPE+vJpiICCD6enFETIyI8RExfuzYsTUuw8zMequT3B8BHomIG/Pjs0jJ/glJSwPkf/9R7xLNzGywhpzcI+Jx4G+S3pIPbQzcA5wP7JqP7QqcV+sKzcxs0OrOUN0XOEXSvMBDwG6kAuMMSbsDDwPb1zyHmZkNUq3kHhG3AeP7+NHGdeKamVk9nqFqZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kK1k7ukuSXdKunC/HhFSTdKmirpdEnz1r9MMzMbjBI19/2BeyuPDweOiIj/Ap4Cdi9wDjMzG4RayV3ScsDmwHH5sYCNgLPyUyYBW9c5h5mZDV7dmvuPga8A/8mP3wA8HRGv5sePAMv29UJJe0qaLGnytGnTal6GmZlVDTm5S9oC+EdETBnK6yNiYkSMj4jxY8eOHeplmJlZH8bUeO36wJaSNgPmBxYGfgIsKmlMrr0vBzxa/zLNzGwwhlxzj4ivR8RyETEO2AH4Q0TsBFwBbJuftitwXu2rNDOzQWlinPtXgQMlTSW1wR/fwDnMzGw26jTLvCYirgSuzN8/BKxTIq6ZmQ2NZ6iambWQk7uZWQs5uZuZtVCRNnfrmw49dFDPjwkTGroSM5vTuOZuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi3k5G5m1kJO7mZmLeTkbmbWQkNO7pKWl3SFpHsk3S1p/3x8cUmXSnog/7tYucs1M7OBqFNzfxX4YkSsBqwL7CNpNeBrwOURsQpweX5sZmbDaMjJPSIei4hb8vfTgXuBZYGtgEn5aZOArWteo5mZDVKRNndJ44C1gBuBJSPisfyjx4ElZ/GaPSVNljR52rRpJS7DzMyy2sld0uuB3wAHRMSz1Z9FRADR1+siYmJEjI+I8WPHjq17GWZmVjGmzoslzUNK7KdExNn58BOSlo6IxyQtDfyj7kWaWVk69NBBPT8mTGjoSuZMw/H7rzNaRsDxwL0R8aPKj84Hds3f7wqcN9RzmJnZ0NSpua8PfAq4U9Jt+dg3gP8BzpC0O/AwsH2tKzQzs0EbcnKPiGsBzeLHGw81rpmZ1ecZqmZmLeTkbmbWQk7uZmYt5ORuZtZCTu5mZi1UaxKTmVlfPElq5LnmbmbWQk7uZmYt5ORuZtZCTu5mZi00qjtU3SljZjY0rrmbmbXQqK65N813BlaH3z82mrnmbmbWQnN0zd1Glmu+Zs1xzd3MrIWc3M3MWsjJ3cyshZzczcxayMndzKyFnNzNzFrIQyGttTzU0uZkrrmbmbWQk7uZWQs5uZuZtZDb3LuY25TNbFZcczcza6HGkrukTSTdL2mqpK81dR4zM5tZI8ld0tzAT4FNgdWAHSWt1sS5zMxsZk3V3NcBpkbEQxHxMvBrYKuGzmVmZr0oIsoHlbYFNomIz+bHnwLeHRH/r/KcPYE988O3APcP4hRLAE8WulzHd/xuit/N1+745eO/KSLG9vWDERstExETgYlDea2kyRExvvAlOb7jj/r43Xztjj+88ZtqlnkUWL7yeLl8zMzMhkFTyf1mYBVJK0qaF9gBOL+hc5mZWS+NNMtExKuS/h/we2Bu4JcRcXfBUwypOcfxHb8F8bv52h1/GOM30qFqZmYjyzNUzcxayMndzKyFnNzNzFrIyX0YSNp/IMdqxJ9vIMdseEhaTNI7CsfcbiDHCp2r+PXnuK+T9JbSca1vXZPcJR0+kGM14n+sj6+NJb2xQPhd+zj26QJxO/44wGODJml/SQsrOV7SLZI+XCJ2r/OsL2nB/P3Okn4k6U0F4yvH/VZ+vIKkdQrGvzL/nhYHbgF+IelHpeIDXx/gsSFp+volfRS4Dbg4P15TUpHh0ZIuH8ixGvG3k7RQ/v4gSWdLWrtmzMVn91XiurtpPfcPAV/tdWzTPo4N1e7AesAV+fGGwBRgRUmHRcRJgw0oaUfgk8BKvd7ICwH/V+9yQdJSwLLA6yStBSj/aGFggbrxs89ExE8kfQRYDPgUcBJwSaH4HccCa0haA/gicBxwIvD+QvGPAf4DbAQcBkwHfgO8q1D8RSLiWUmfBU6MiAmS7qgbVNKmwGbAspKOrPxoYeDVuvErGrn+ikNIa05dCRARt0lasU5ASfOT3udLSFqMnu//ZevE7uXgiDhT0gbAB4EfkN6v764RcwoQzLjmqgBWqhEb6ILkLunzwN6kBFl9sy0EXFfwVGOAt0bEE/m8S5KSy7uBq0kJbbCuBx4jrRfxv5Xj04ESH5yPkO4AlgOqtaxngW8UiA8z3nybASdFxN2S+npD1vVqRISkrYCjI+J4SbsXjP/uiFhb0q0AEfFUnmBXyhhJSwPbA98sGPfvwGRgS1JC6JgOfKHgeZq6/o5XIuKZXm+duuOw9wIOAJYh3W10PAscXTN21b/zv5sDEyPit5K+UydgRNQq2AZ6klH9BSwCjANOA95U+Vq88Hnu6fVYnWPArTXizg1c0fDv6OMNxj6BVEt/gFRLWgiY0sB5riI1M/wJWIrUZHhnwfg35r/FLfnx2Dp/1z7ib0sqsI/Jj1cCflMw/jzA64C3NPR33i5f/7ENXf/xpLvYO4BVgKOAnxWKvW8Tv5NK/AuBnwMPAYsC8wG3F4otYGfS3QHACsA6RWI3+Utp4Jc8N6mUXqHzVTD2MfmPuGv+Oj8fW7BucgYuJ932NvV7WSp/eC7Kj1cDdi8Uey5gbWDR/PgNwDsa+j8cCLw3P14B2KVg/J3y3/QR4LukVUi3Kxh//YEcqxH/o/ma/5wfrwmc39R7qoG/7wL5935z/voOMH+h2AsCB5Fq1eTCY4vC1/4xYJX8eGngw4ViH0va++Le/Hgx4OYSsbtmhmpezuAQ4AlS2ylARESRXv3c1PBxYP186DpSzaX2L0jSecBawKXA853jEbFf3dg5/kWkGvY3I2INSWNItdLVC8XfEnhffnhVRFxQIm6vcywIvBgR/5b0ZmBVUmH1SsFzrApsTKotXR4R9xaMfUtErN3fsRrxp5D6C66MiLXysTsL/o2XI9WmO+//a4D9I+KRArHnBi6LiA/UjTWL+KeTmqx2iYi3S1oAuD4i1ix4jjWA9+aH10TE7YXi3hK5ubDyd709ItaoG3vUt7lXHEC6Jf1nE8FzEj8rf5V2dv5qyhIRcYakr8Nra/v8u78XDYSk/yF1Op6SD+0nab2IKNWm33E18N7cMXYJqXb3CVKNu5QnSElrDKkTeu2IuKWf18yWpPWA9wBjJR1Y+dHCpDvNUppos646ATiV1DwDqangBNJAhlpygf0fSYtExDN14/Vh5Yj4RB7AQES8ULJfSGnY8h7M+AyfLGliRBxVIPwrufCLfK6xzKi81tJNyf1vQBNvDCANhQQOB95IqtmJlPMXrhs7Iiblzrs350P3l6yRAs9LegMz3iDrUu53tRmwZkT8J8eeBNxKuQ7bDuUP5e6kduvvSypSOwKQ9G1S5/ODzEiKQaoN1zEv8HrSZ2mhyvFnSe3wpdwt6ZPA3JJWAfYjddiXMjYiTqg8/pWkAwrGfw64U1ITd68vS3odM97/KwMvFYjbsTupQ/75HP9w0lDjEsn9SOAc4I2Svkt6zxxUIG5XJfeHgCsl/ZbKHy4iSo3F/T7w0ZK36h2SNgQmAX8hFRrLS9o1Iq4udIoDSe3JK0u6jtRZWDKxLMqMoZuLFIxbpVwL3on0YYKy8zC2J9XwXi4Yk4i4CrhK0q8i4mFJC0TECyXPke1LGsXyEmlwwe+BbxeM/09JO+fYADsCJe+Sm7x7nUAaP7+8pFNITUufLhhfzBgxQ/6+yJ1BRJySm9w6zYVbl8pB3ZTc/5q/5s1fpT3RRGLP/pfUAXM/QG5TPg14Z4ngEXGLpPeTtisUZe8MvgfcKumKHPt9wNcKxa46gDRa5pxIwy1XYsacgxLuIhVS/ygYs2qZ3PfxemCF3Ea7V0TsXSJ4LjC+STPDFAE+Q6qJHpEfXwfsVip4REwqFauP2JdKugVYl/Qe3T8iSm6FdwJwo6RzcvytSAMYastzF34dET8tEa9H7G7pUO1oqmYk6SekERvn0vPOoHZtQ9IdvTt++zpW8xzvIQ0Zfa3AjogTC8VemtTuHqSe/MdLxJ3FuZr6+44HziMl+erfd8tC8W8k3S2dX+kYuysi3l4o/puBLzHz37hus9KwyE1J3yON5Jq/czwiak/WyfGXJQ2Rrv5uSt0ZozQjdQPSZ+DaiLi1UNxdSX1LbyE1z/w6IiaXiN01Nfd8y348DdWMSB1gLwDVqfVBmVvJyZKOA07Oj3ciTUwpQtJJwMqk6d2d28cgTcIqYT1mvLHHkN6ERQ3D33cSqU/lTgp1WPUWEX/r1Y9XpFM7OxP4GWnmbsm4AOQ7pZ+Qar9BalP+QkQ8VOgUJ5CaT44APkC6KyjS7JbbwD8B3E1lJB2pk74kMetZpUOS72gmKS058HHgcEkrRMQqJYJ3xRdpEsryVCaeAHeN9HUN8NrnI7WLd9odvwDMVzD+veS7sAau/RjS6JXd8tfFwE+77e9LobHDs4l/FmnUzC2kCUdfItXCSsUvPnGsV/wbSEtLjMlfOwM3lr5+KhPTSv2fSOP/i32e+oj/LVKl4BDgUOB24KDC51iH1Hw7FbigRMyuqblDMzUjSV+JNDLjKPoYWhYFevMj4iVJR5MmM/2H1CZesmPvLlKT0mMFY3ZsRFqWoTMSYRKphlRcE3/fimskfY/U8Vxtlqk1FLLic6Sa77KkJQN+D+xTKDbABZL2Jt01Va+/9hpF2QLRc/2kkyV9uVBsgJckzQU8kOesPEq6SyvhIVKBWnKETNVOwBoR8SK8Njz4NtJErFokfR/YhjSK63Tg2xHxdN240EXNMsDfcrtySJoH2J9UY62rE6NYM0lvkjYn3VI/SLqlW1HSXhFxUaFTLAHcI+kmyrcnTyXNFn04P14+Hyutqb9vx1r533Urx0oMhUyBUgdeyTH5ve2a/60m3CILTGUXSfoa8Osc9xPA73JzQYlCZH/STM/9SKN8PkDfq6UOxQvAbUorQVbf/0UmCZIK6/mBF/Pj+UiFUwkPAutF2Q5goIs6VCUtQaoZfZCUIC8h9Yo3MqmpJEn3kaZDT82PVwZ+GxGrFor//r6ORxqmVzf2VaTO1JtIH/p1SAXhM/kcpToku/bvC8PSZt3f+T8UEZfWeP2fZ/PjiEIdn03InZIziUIjdCSdS/oMXEr6236I9Hl4JJ+nViGSJ+6tQs+O5tr9BV2T3JvW5GgESTdHxLsqjwXcVD3WJEl/jIj1hvjaPguOjhIFyHCQtAipQ++1ZRSAw6LQjElJN5DWCOmME9+BtKBVnWVhB3P+YksdzCJ+3cLjUtJaPk/nx4uR+iQ+UugSZ3fu30TEx2u8frZ3GHUKEaUllvcnrex6G6ly8McieadbkrvS2s/7MnPyLVVzvJ3UdDKFSltvREyZ5YsGHvtY0jCtM0gl/3akMfuX5XM0uTQBqqxb0UDsIRccveKMJU3xHkfPv+9n6sbO8X9D6pvofBA/RWpH/Vih+H0Ndy2yRsgAz9/Y3zjHr1V49HV9TV/zcJ2nTuEh6U7SXcENEbGm0vpH/13ifdlNbe7nkobKXUAzQ9lejYhjG4gL6XbrCWZsPDGNtHzrRyk33HJ2mizB5+//KQNyHmndl8toYKgfaXZq9QN4qKTbCsZvus26P03X0uoO//tPHuL3VwClXbaGq2bZ9HnqNFm9GBEvSkLSfBFxnwptRdhNyf3FiDiy/6cNWWOjESKi2Ey/UajUB2eBiCi1q1Zf/iVpg4i4FkDS+sC/CsbfPv+7V6/jO1C243Ok1P07fxO4NvfhiLTC4p61r2p0qPO7eUTSoqTK66WSnmLG4IVauim5/0TSBFJHWxND2RobjZCHO32HlEwuBt5B6mw7ebYvLKeJnZNKu1DSZhHxu4bif540WaSzNs5TlButQfSzs07dNusB+EuDsWuLiIvzLM/OaKUDqiNEJL0tIhoZYssofv9HxDb520PyEh+LkPeZraub2ty/R2onfZCe67mP+unXkm7L7WnbAFuQJjRdXao9VtK+wMkR8dQsfv72iLirxLn6iF2kPVPSdNKmCy8Br1BwVc4cfz7S8gArk9aYeSbHP6xE/AGcv26b9T7AKb06JHeMiGMKXWJ/5z+7VP/ELOI31iEs6cMRUXrP32r8IX0GlJb6vbvUqLneuqnmvh2wUuHJP0jaKCL+oLTk70wKdXZ2fs+bA2fGzOty17UkcLPS4km/BH4flVK7TmLvr+AgFbi1RcRC/T+rlvOAp0kzSEuNUR6Mun/wPaKyuFSkPWD3IM0grq2/wqPJxN65hCG/MHVK9q6lPkMasvudJhN7NqTmxEjr3N9f7YsoqZuSe1Or+r0f+AOpc7O3Up2dF+ax7v8CPp9HhrzYz2sGLCIOknQwaV2c3YCjJZ0BHB8RD9YM31jBUSXp8ojYuL9jNSwXEZsUijUUdW+R55akzu8+1/pKro7aaOExAHV+PxeROuFPzY93IE2Yehz4FX1/tges4cJjMdJa/TfRc5372qMAuym5LwrcJ+lmCs7CjIgJ+d/GOj0j4mu53f2ZXFo/T1o2tOQ5QtLjpDf0q6Q3zVmSLo2Ir9SI22TBgaT5SR/EJXJtsVODW5g0lb+U6yWtHhF3Fow5nC4GTpf08/x4Lwq1zWZNFx5N+mCvJp07NWP7up0LxG+y8Jif1FTbIdICd7V1U3Kf0ERQ9dwabSZRbjOQVYFxSvubdpRaknd/YBfgSdKqgV+OiFeU1/IAhpzcobmCI9uLtJb7MqQmk45ngaNrxq7WusYAu0l6iFQ56LTpF1t2uR9/qfn6r5JGl3w+P76U9LcupenCoz91mlvnlrRORNwEIOldzNji8NXaV9Zs4TEmek0EVNpVqrau6VBtSh6BA2k95XeRFpaCVBrfFBG1S37NYkneKLdB9iHACREx0xAqSW+NGpuQ9FFwnFstOCJi5aHG7nWefaPMnpS9475pdj/v63c2xPNsB1wcEdMlHQSsTbplLzWaq3quxUnNTHcUjDkXqfD4YD50KXBcRNSac5BHyMxSid9PTua/JC1EJlLF4LOkBe42j4gzasa/ndRsVS08jou0Gf1QO1M/D+xNGo1XvQNeCLiuSN7pluSuBvc4zfGvJr0RpufHC5HWf3nf7F85oNj3AqtFA7/spnvcmyw4cozh6NBunPIMVUkbkIa9/gD4VhRafkDSlcCWpDuQKaS+p+sj4gsl4vc6V7HCIw/vm5Wio906w1yj8CbcTRQe+VoXI21gUt3ZbHoUmvDWTc0yje1xmi1Jz1vDl/OxEhpbkrfJHvdccOwQEYfM4twl/hbvo/kO7eHQqeFuDkyMiN9Kqr0kbMUiEfGs0lokJ0bEBEkla+5X0qvwkFS78IiIDxS4vNnKw1w/Tl66ojMSrdQw14i4GVh9FoXHkO4KcoxnSHvVNqKbknuTe5xCav++SWmfRICtSZ0lJTS5JC801OPe9FCtrDPE8vjIs0e71KO5vfpDpN105qPsBt9jlLY73J5m9lFttPCANN+CmbfZK9HvdB4pUU6hgTXdmy48mtJNyX2ypNNpYI/THOe7Shscvzcf2i0q+yRKWmw2Y737c0jd6+vHwQ3GbmyoVrYbaancI0nt1N1qe2AT4IcR8XROxCU3uziMtAHItRFxs9ISww8UjN9o4ZH7tjYkJfffAZsC11JmUEHTw1wbLTya0k1t7if0cTii0KqBAzh/o0uq1pU7DleJiMskLQDM3ek/qBm3sbXic/zTgPGk0TLVjqXhHs0yJLl9epZKtZ82LXcIH0wqPPbOhccPosZSub3i3wmsQdpGcQ1JS5Imx32oQOyJwFFNDXNVwY3Oh1PXJPeRNtRe8fzadYGjgLeSxg7PDTxfsDN4D9JIh8UjYmWlneZ/FoUmADVVcFTiL0Wqlc50N1BqNEtTlDa56GyavAKpmUmkeRl/jX7WnBlA/Ma3gRwOkm6KiHUkTQE+AEwH7i0xEEDSPcB/AX+mgWGuTRceTRn1zTKj6M1dpxQ8mjTx4UxSLXUX4M0lLirbh7RD0o0AEfGApDeWCFwtOEjDOZclrXtfauYoEfE4qVY3u+uoteFCUzrJW9IvgHMiL3wmaVNSv01d1W0gmxhtNVyfr8lKqx/+gtS88Rxpt6oSNi0UZ1Y2AD6dC/KRmCMxJKM+uTMMe5wOh4iYKmnuPG74BEm3Al8vFP6liHi509GTJ0qVSgSNFRyDNNqXzF03IvboPIiIi5RmJdcSERfkb+8BvkHPzUyC+m3WjRYeHRGxd/72Z5IuBhauO9RS0sIR8SzpLqBJTRcejRj1yb3z5o5C+yHWUGfhpxckzUvaxPf7pCGRJUdSXCXpG8DrJH2INDnign5eM1BNFhyDMdrbD/+eJy91lnHeibSxciknkzpo76TgZjXDUHi8RtKypB3JxuTH74t6e4WeSpq6P4UZTWMdtZfrHsbCoxFd0+autNjWV5l5KFWtSRAD7RCTtPhQO8dym/UTpPb2L5DWbD4m8obZdeXZhbuT1n8Rqf36uBKTpnJh9DSpKWlfUsFxT0Q0MRxvdtcx2ju0F6fnHq1XA4eW6lCVdG1EbFAi1izi308fhUepPg9Jh5N2p7qHnrO0S426Kk7ShRGxRa9+lY6IUbxpOHRXcr8EOJ20ifXnSBstTIuau/cMQ4fY3KRxwzvVidPPORYk7VT178o554uIFwrEbqzgGOR1DLlDuw0kbUya8HI5DQwFHqbC4x0R0chQwjzDeQPSZ/maiDi3ifN0k25K7lMi4p2qbEQs6eaIeFeh+H12iEVE723ThhL7WmCjKLwWfSX+DaTFjZ7Lj18PXBIR7ykQu7GCY5DX0eiGC0Ml6ccRcYCkC+i7Q7LUBu4nkxafu5uem9WU2kC86cLjImC7znu0JEnHkEbLnJYPfQJ4MCL2KXiOris8Rn2be8Ur+d/HJG1Oas+cbZPKIDXSIZY9BFwn6Xx6TgQqteLk/NUPTUQ8l4cslnA5aTGpTvzXkbY6rF1wVCntaXoIM9pkOyMSViJ9M+oSe3ZS/vcq4OZePyu5Acm7IqLIxsmzsBup8JiHSuFBueUfXiD1OfUuPEqMxtkIeGvnblLSJFIhWEQfhcfnlLZNLFZ4NKGbkvt3lNZ2+CJpzPjCpKViS2myQ+zB/DUXMz7wJW+Znpe0duQV9iS9k3KbPzdZcFQdT+qPmMKMNtlRLyKm5G8/SVoV8i4ASTuS3p8XFjrV9ZJWi4h7CsXrrenC43xmrLha2lRSk2qnf2D5fKyURguPpnRTcn8qZiy28wF4rbZXyo6kDrHO2jJXU25Rn3si4szqgTwjsJQDgDMl/Z1U412KdGtaQpMFR9UzEXFRA3GHy7akNe4/SVrCYhdSP0Up65Jqvk2NtW608IiISXnEWGd+x/0R8crsXjMICwH3Ki2RAWnp7sn5TrlE01jThUcjuqnNfabREk2MoFBa6jdKtg0Ox7VLmoe0Jj0U/OAoLXf6a9JdzGsFR6XGWjd+53ewPWnm7tn0vG0vvh56UyS9mbT20V+BbSKiWCGoWaxLX3A0y72kSWpNzfLcEJhE2rREpAS5a82hkJ3YfS6R0RE1l8qQdBWpwOhReJAqmiXXWSpq1Cd3SeuR2ncPAI6o/Ghh0gdotjMbB3Ge1Uljejvt+E+S3nx1NpfeFNiMlLhOr/xoYdL67usMNXav88xD2qGnMwzvSuDnBRN8IwVHjj1s6303QTPvr/lG0of+JYCCNetGDUPhMQX4ZETcnx+/GTgtIt5ZKP5SpMl2AdwcadZzEU0XHk3phmaZeUmL5I+hZwfVs6Rb4VJ+DhwYEVfAazWNidTrOPw7qYTfktSW3DGd1L5cyrGkjrDOZsafysc+WzdwXwWHpGIFR+T1viWtFBEP9Tr3qB5HnG3R/1NGv1JJfDbm6ST2fL4/5fdWbUrLFH+LtC+AgKMkHRYRvywRPyKuarLwaMqor7nDa8PvzogG1xaRdHvvu4C+jg0x9jyzS4aquW5Kw9d+HKng6MwQ/hTw74ioXXD0Ok9fTVdTStXsbGRJ+iVpFE5nwMLOwFwlhnLmMfTviYh/5sdvIO1SVaSDuI/C4/1AscKjKd1Qc+9sGrFMw6d5SNLBzBjatjNpCGNtA6jl1q2h/lvSyhHxILxW4y014uRdvQqJPyjtKVmEpFWBtwGLqOdWewtTmYlsXe/zpHWKOkMfr2HGnWZd/6TnEgHT87FSvgys1bvwIG29N2p1RXLPbsu932fSc6x4qXG4nwEOZca43mvyseFQ9/bpS8AVkh4i1SzeRBq3XEKTBQektvwtSDOCq1vtTQf26OsF1n3yzNQfAT/SjD1aS81WnQrcKOk80mdpK+AOSQfmc9edT9J04dGIbkru85N+odUOtmKTLCLtsrRfE6NlmpSbrNYAVqFnp2epD06TBQcRcR5wnqT1IqLUErA2yqihPVqzzjySjvPyv6UmkTVdeDSiK9rch0MTo2UGce5bo8a6KcobIZS8phx3btJt9DE0U3CgWawj3lFoBqONsM57PLdfLx95j9aSo4nyshuUrpgpbRE4SxFxaMnzldI1Nfc8dOpYYMmIeLukdwBbRkSpHeabGC0zE0mLkd7c1bWsay1+Rlra4GjScMtqk1WtMeK5r2PHiDgCKLpZckVXr9NvA9bYHq1KG2+fRK6YSXoS2CUiiswi7STvpgqPpnRNzT1PJPgyafz2WvlYsb0NGx5xciW9bkmB6yLiwLqxc/zOWPHOH7MzAaX2GHFJR5BGyxQtOGzOImlb0oiT4nu0Sroe+Gavitl/R4GF83K8HoUH6a6+WOHRlK6puQMLRMRNUo89M14tGL+x0TLAIhHxbL4lPbFzS1ooNqT1S6rrTQfwrKQ1I+K2mrHXzP92bj2V4xedXKSG1uu3kZeb95avNsHkOQ2lhjYv2EnsOfaVSquZljKRme/qf0Hhu/rSSu4G1LQnJa1Mrp3mmsBjdYNK6iTza4CxpA7as4ElKDdapnpLWmohqap3kta4XxpYBtgL+AjwC0lfqRn7QtKuTr/NXxcAp0pas2bc3k4hbfm2Iqkg+Qszr7JoXSjSctGl1mnqy0OSDpY0Ln8dRLmKGfRReAAlC49GdFOzzErMaAN/irQGxk51Z9Yp7Zz+QeAi0oJknZopMGMnpprn2A44mAZuSXP8q4HNoud67r8FNgGmRMRqNWKfStrU+3zS72YLUvv7OODMiCiyLLIaXq/fRlaTzXu5H+tQ0nrrkCpqh+QRcLVJOge4hZ539e+MiG1KxG9KNyX3FSPiz/l2a66ImN45VjPufqQJFisBj1Z/RBdspQUg6T5g9c5kKUnzAbdHxKoFRuI0VnD0Os8NEbGupN8DR5KWbjgrIlYuEd9GlvpeQ6hIv1DTmi48mtJNbe6/AdaOiOcrx84iNUkMWUQcCRwp6diI+HydWLMiaX7SVnVvo2d7cqlmn1OYMQ4X0mSgU3NBWHcJ1zdSWaWRtGnKkhHxL0klt0zra73+kuvv2AiKvIZQE/JIui/Rc3PvYv01nTkwJWINp1Gf3IdrenpTiT07CbiP1A5+GGkjkHtLBY+IbyttY9ZZ3/5zEdEZYlh379YmC47XRESnL+K19fqtPSQtCfw3sExEbCppNWC9iDi+QPgzgZ8Bx9HARi9NFx5NGfXNMpK2ArYmDSWs7uQyHfh1RFw/Etc1GJUJHHdExDuUVsO7JiLWHelrGwhJ45lRcFxXKThKnqPpeQw2gnLl4wTSkMU1JI0Bbo2I1QvEbnSBubyW0s/otUtYFNrToCmjPrl3dPP09M4M0tx+vTfwOHBTN7TnD5em5zHYyOp0jlf7gCTdFhFr1ojZGXe+H2nuyDn03Oil9mCIfJ6uXJ101DfLVEyV9A1mvjUarsW96piYO2UOIt19vJ40esZmaHoeg42s55VWU+wMZV6XvJNRDVPoOb/jy9BjKYtaladK4XGBpL1pqPBoSjcl9/NIvdSX0UUbKGeLMGOxrZ/mf18tNMmoLRqZx2CjxoGkis1Kkq4jzSmptdlORKwIIGl70ubkz+aJiGsD3655vdBw4dG0bkruC0RE3TVYRso7SWPFL8iPO2PFPyep2FjxLrcPaR7DqpIeJc9jGNlLsoLuIdV8XyD1l50L/KlQ7IMi4gxJG5BmTv+Q1H/z7jpBh6HwaFQ3tbl/h7S7yu9G+loGa7jGinezPDZ/W1Kz2+KkbRQjIg4byeuyMiSdQfqbnpIPfRJYNCK2KxC7M2Dhe8CdEXFq3fkdveJ3BkJsQErqPwS+FRG1Co+mdVPNfX/g65JeJo217kwyWnhkL2tAhmuseDc7D3iaNBPw7yN7KdaAt/eqxFyRZ4eX8KiknwMfAg7PFYWSS6t0moE3B34REb/Nlc1RrZuS+yKk2/QVI+IwSSuQ1lLpBsMyVrzLLRcRm4z0RVhjbpG0bkTcACDp3ZRb7nl70l3wDyPi6byO05cLxYbmC49GdFOzzLGkDXY3ioi35tEnl3TL2iPDMVa8m0maCBwVEXeO9LVYeZLuJW348td8aAXgftKIqIiCm3aUJmkBUuFxZ0Q8kAuP1SPikhG+tNnqpuR+S0Ss3WucbJH11m3kSLqTNAJhDGmrwIdITVidZrdR+6G3gZP0ptn9vO4CgDazbmqWeUVpXejOULmxpJq8dbctRvoCrHlO3sOvm5L7kaShVG+U9F3SyIqDRvaSrC5/6M2a0TXNMvDaImIbk27ZL4+IYotvmZm1SVcldzMzG5hRP5zHzMwGz8ndzKyFnNxtjiRpQ0mjevd6szqc3G1OtSFps/XGKPFnzEaE33jWKpJ2kXSHpNslnSTpo5JulHSrpMskLSlpHPA54AuSbpP0XkljJf1G0s35a/0cb6ykSyXdLek4SQ9LWiL/7EBJd+WvA/KxcZLul3QicBdwsKQfV65vD0lHDPOvxeZAHi1jrSHpbaS5EO+JiCfzZgsBPB0RIemzwFsj4ouSDgGei4gf5teeChwTEdfmdYt+n5e5OBp4NCK+J2kT4CLSWuRvAn4FrEsamnsjsDPwFGmW7Xsi4oa8AujtwKoR8Yqk64G9vMyCNa2bJjGZ9Wcj4MyIeBLSTjmSVgdOz+uBzEtaJ74vHwRWq+wEtXBOzBsA2+R4F0t6Kv98A+CciHgeQNLZwHtJG1I83FkgKyKek/QHYIu8vso8Tuw2HJzcre2OAn4UEedL2hA4ZBbPmwtYNyJerB7ste3fQD3f6/FxwDeA+0ibRJs1zm3u1iZ/ALbLe3V29sBcBHg0/3zXynOnAwtVHl8C7Nt5IGnN/O11pCVlkfRhYLF8/Bpga0kL5KWbt8nHZhIRNwLLkzaoOG2I/zezQXFyt9aIiLuB7wJXSbod+BGppn6mpCnAk5WnXwBs0+lQBfYDxufO2HtIHa4AhwIflnQXsB3wODA9Im4htbnfRGpvPy4ibp3N5Z1BWur5qdk8x6wYd6iazUbemOHfEfGqpPWAYyNizSHEuRA4IiIuL32NZn1xm7vZ7K0AnJHHq78M7DGYF0talFS7v92J3YaTa+5mZi3kNnczsxZycjczayEndzOzFnJyNzNrISd3M7MW+v/RijfE/oE7/wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample.filter(col('is_fraud') == 1)\\\n",
    "    .select('category')\\\n",
    "    .groupBy('category')\\\n",
    "    .count()\\\n",
    "    .orderBy('category')\\\n",
    "    .toPandas().plot.bar(y='count', x='category', title='Fraud', legend=None)\n",
    "\n",
    "df_sample.filter(col('is_fraud') == 0)\\\n",
    "    .select('category')\\\n",
    "    .groupBy('category')\\\n",
    "    .count()\\\n",
    "    .orderBy('category')\\\n",
    "    .toPandas().plot.bar(y='count', x='category', title='legitimate', legend=None)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also seem to carry some information about fraud. Because it is categorical data, it will need to be encoded to be suitable for regression models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"distance\"></a>\n",
    "#### 4.2.7. Distance to Merchant\n",
    "\n",
    "The distance to the merchant may be relevant. The following cell is a helper function to compute distance from geo coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(lat, long, merchant_lat, merchant_long):\n",
    "\n",
    "    # approximate radius of earth in km\n",
    "    R = 6373.0\n",
    "\n",
    "    s_lat = np.deg2rad(float(lat))                      \n",
    "    s_lng = np.deg2rad(float(long))     \n",
    "    e_lat = np.deg2rad(float(merchant_lat))                       \n",
    "    e_lng = np.deg2rad(float(merchant_long))  \n",
    "\n",
    "    d = np.sin((e_lat - s_lat) / 2)**2 + np.cos(s_lat) * np.cos(e_lat) * np.sin((e_lng - s_lng) / 2)**2\n",
    "\n",
    "    return float(2 * R * np.arcsin(np.sqrt(d)))\n",
    "\n",
    "distance_udf = udf(lambda lat, long, merchant_lat, merchant_long: distance(lat, long, merchant_lat, merchant_long), FloatType())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applying the function to the dataframe, using the `lat`, `long`, `merch_lat` and `merch_long`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sample = df_sample.withColumn(\"distance\", distance_udf(col('lat'), col('long'), col('merch_lat'), col('merch_long')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The comparison between legitimate and fraudulent transactions can now be plotted as a histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Fraud vs. Legitimate'}, ylabel='Frequency'>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sample\\\n",
    "    .withColumn('fraud', when(col('is_fraud') == 1, col('distance')).when(col('is_fraud') == 0, None))\\\n",
    "    .withColumn('legitimate', when(col('is_fraud') == 0, col('distance')).when(col('is_fraud') == 0, None))\\\n",
    "    .select(['fraud', 'legitimate'])\\\n",
    "    .toPandas().plot.hist(by=['fraud', 'legitimate'], histtype='bar', bins=100, logy=True, title='Fraud vs. Legitimate', xlabel='Distance', secondary_y='fraud')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Distance doesn't show to be an important factor. In fact, the travelling flag is disabled in the generator code. This feature can be kept for when the flag is enabled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"features\"></a>\n",
    "## 5. Feature Engineering\n",
    "\n",
    "Since many machine learning models expect numeric values as input, and many of the dataset columns are string columns, these need to be encoded to test various models.\n",
    "\n",
    "For the customer information:\n",
    "\n",
    "- The value for `gender` is `male` or `female` so it can be dummy encoded.\n",
    "- The `street`, `city`, and `state` are difficult to 1-hot encode as this type of encoding assumes a fixed set of categories. `zip` actually encodes these values fairly accurately so it could be used alone, however despite being an integer, it is technically categorical data and not numeric.\n",
    "- The `long` and `lat` pair of values is a better representation of the city location and potential area for fraud. Distance to the merchant is a metric of interest in this model, so `lat` and `long` are the better columns to use.\n",
    "- The `dob` (date of birth) column is useful information but customer profiles use `age`, `age` will be computed from `dob`.\n",
    "- The `city_pop` column defines whether a city is urban or rural, which is part of the profiles.\n",
    "\n",
    "For the transaction information:\n",
    "\n",
    "- The `amount` column is important.\n",
    "- The merchant `merch_long` and `merch_lat` columns are needed for distance calculation.\n",
    "- The merchant `category` is a categorical column that needs encoding.\n",
    "- The transaction date and time need to be augmented to extract additional useful features.\n",
    "\n",
    "In conclusion, you will:\n",
    "\n",
    "- Keep and encode the `gender` column.\n",
    "- Compute `age` from `dob`.\n",
    "- Compute time of day, day of the week, if the day is a weekend, and the month of the year from the transaction date.\n",
    "- Use `long` and `lat` to compute distance to the merchant.\n",
    "- Use `city_pop` to represent city area.\n",
    "\n",
    "\n",
    "With the identified features, you will put it together into a single function for feature engineering that includes the necessary transforms.\n",
    "\n",
    "This includes the 1-hot encoding for the `category` column we have not worked on yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"build_features\"></a>\n",
    "### 5.1 Build the feature set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_feature_columns(df):\n",
    "    # Augments the dataset with features we identified\n",
    "    \n",
    "    # drop unneeded columns\n",
    "    df = df.drop('ssn', 'cc_num', 'first', 'last', 'street', 'city', 'state', \n",
    "                 'zip', 'job', 'acct_num', 'profile', 'trans_num', 'unix_time', \n",
    "                 'merchant')\n",
    "\n",
    "    # transaction date and time features\n",
    "    df = df.withColumn('day_of_week', dayofweek(col('trans_date')))\n",
    "    df = df.withColumn('month_of_year', month(col('trans_date')))\n",
    "    df = df.withColumn('hour_of_day', hour(col('trans_time')))\n",
    "    df = df.withColumn('is_weekend', col('day_of_week').isin([1,7]).cast('int'))\n",
    "    \n",
    "    # distance\n",
    "    distance_udf = udf(lambda lat, long, merch_lat, merch_long: distance(lat, long, merch_lat, merch_long), FloatType())\n",
    "    df = df.withColumn(\"distance\", distance_udf(col('lat'), col('long'), col('merch_lat'), col('merch_long')))\n",
    "    \n",
    "    # customer age and gender\n",
    "    df = df.withColumn('age', floor(datediff(col('trans_date'), to_date(col('dob'), 'yyyy-mm-dd'))/365.25))\n",
    "    df = df.withColumn('gender', when((col('gender') == 'M'), 1).when((col('gender') == 'F'), 0).otherwise(-1))\n",
    "    \n",
    "    # drop no longer used columns\n",
    "    df = df.drop('dob', 'trans_date', 'trans_time')\n",
    "\n",
    "    return df\n",
    "\n",
    "def create_feature_encoding_pipeline(df):\n",
    "    # Create a pipeline model encoding categorica features\n",
    "    # which can be re-used to evaluate the model\n",
    "    \n",
    "    # 1-hot encode merchant category\n",
    "    stringIndexer = StringIndexer(inputCol='category', outputCol='category_index')\n",
    "    encoder = OneHotEncoder(inputCols=[stringIndexer.getOutputCol()], outputCols=['category_classVec'])\n",
    "    \n",
    "    stages = [stringIndexer, encoder]\n",
    "    \n",
    "    numeric_columns = [col[0] for col in df.dtypes if col[1] in ['int', 'double'] and col[0] != 'is_fraud']\n",
    "    assembler_inputs = ['category_classVec'] + numeric_columns\n",
    "    assembler = VectorAssembler(inputCols=assembler_inputs, outputCol=\"features\")\n",
    "    stages += [assembler]\n",
    "    \n",
    "    # put together the pipeline with the indexer, encoder and vector assembler\n",
    "    pipeline = Pipeline(stages=stages)\n",
    "    # fit the pipeline with the dataset\n",
    "    pipeline_model = pipeline.fit(df)\n",
    "    return pipeline_model\n",
    "\n",
    "def encode_features(df, pipeline_model):\n",
    "    df = pipeline_model.transform(df)\n",
    "    df = df.drop('category_classVec')    \n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting it all together: \n",
    "- Create the feature columns\n",
    "- Create an encoding pipeline\n",
    "- Encode the features with the encoding pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "df2 = create_feature_columns(df_sample)\n",
    "pipeline_model = create_feature_encoding_pipeline(df2)\n",
    "df2 = encode_features(df2, pipeline_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataset now includes the encoded features as a vector column named `features`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- gender: integer (nullable = false)\n",
      " |-- lat: double (nullable = true)\n",
      " |-- long: double (nullable = true)\n",
      " |-- city_pop: integer (nullable = true)\n",
      " |-- category: string (nullable = true)\n",
      " |-- amt: double (nullable = true)\n",
      " |-- is_fraud: integer (nullable = true)\n",
      " |-- merch_lat: double (nullable = true)\n",
      " |-- merch_long: double (nullable = true)\n",
      " |-- distance: float (nullable = true)\n",
      " |-- day_of_week: integer (nullable = true)\n",
      " |-- month_of_year: integer (nullable = true)\n",
      " |-- hour_of_day: integer (nullable = true)\n",
      " |-- is_weekend: integer (nullable = true)\n",
      " |-- age: long (nullable = true)\n",
      " |-- category_index: double (nullable = false)\n",
      " |-- features: vector (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df2.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"split_set\"></a>\n",
    "### 5.1. Split Train and Test sets\n",
    "\n",
    "You will now split the dataset into train and test subsets with a ratio of 80:20, so 80% is used for training and 20% is kept aside for testing. The testing set must be data the model has never seen before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset Count: 70587\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 84:=====================================================>  (19 + 1) / 20]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Dataset Count: 17437\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "train, test = df2.randomSplit([0.8, 0.2], seed = 2018)\n",
    "print(\"Training Dataset Count: \" + str(train.count()))\n",
    "print(\"Test Dataset Count: \" + str(test.count()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"rebalance\"></a>\n",
    "### 5.2. Balance Classes\n",
    "\n",
    "Fraud amounts to about 1% of transactions, so the dataset is strongly unbalanced. To give the fraud cases more weight during model training, the legitimate transactions are down-sampled to 5% of the original set. This is done on both the training set and testing set so the testing set matches the training set shape.\n",
    "\n",
    "The scoring set will later be used to test the model on the more realistic unbalanced dataset to evaluate what can be expected for its actual performance.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 86:==============================>                         (11 + 9) / 20]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-----+\n",
      "|is_fraud|count|\n",
      "+--------+-----+\n",
      "|       0| 3511|\n",
      "|       1|  410|\n",
      "+--------+-----+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "train_downsampled = train.sampleBy('is_fraud',\n",
    "                                    fractions = {\n",
    "                                         1: 1,\n",
    "                                         0: 0.05\n",
    "                                     }, seed= 1234)\n",
    "train_downsampled.groupBy('is_fraud').count().orderBy('is_fraud').show(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 88:=======================================>                (14 + 6) / 20]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-----+\n",
      "|is_fraud|count|\n",
      "+--------+-----+\n",
      "|       0|  909|\n",
      "|       1|   84|\n",
      "+--------+-----+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "test_downsampled = test.sampleBy('is_fraud',\n",
    "                                    fractions = {\n",
    "                                         1: 1,\n",
    "                                         0: 0.05\n",
    "                                     }, seed= 1234)\n",
    "test_downsampled.groupBy('is_fraud').count().orderBy('is_fraud').show(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"eval_helper\"></a>\n",
    "### 5.3. Model Evaluation helper\n",
    "\n",
    "To evaluate the performance of our model, the receiver operating characteristic (ROC) curve, the Precision / Recall curve, and the confusion matrix, are useful metrics that give indications about rates of false positives and false negatives.\n",
    "\n",
    "The next cell is a helper function to compute these functions, which can be used to evaluate the different models you will try.\n",
    "\n",
    "- The model decision function provides a way to introspect the ability of the classifier at different thresholds or steps of the fitting process.\n",
    "- The Receiver Operating Characteristic (ROC) Area Under the Curve (AUC) provides a single metric measuring the area under the ROC curve. The ROC curve looks at False Positive Rate vs. True Positive Rate across the decision function. \n",
    "- The Confusion Matrix shows the number of True Positive, True Negative, False Positive, and False Negative, that is, the number of predictions that were correctly assigned to True or False as well as incorrectly classified. \n",
    "- The Precision / Recall curve provides another way to look at model performance. Precision is the ratio of correctly predicted fraudulent transactions over the number of predicted fraudulent transactions. Recall is the ratio of correctly predicted fraudulent transactions over the number of fraudulent transactions in the dataset. Ideally, both are close to 1.0.\n",
    "    \n",
    "The ROC and PR curves are useful because the curves of different models can be compared directly.\n",
    "\n",
    "ROC curves should be used when classes are balanced, while Precision-Recall curves are most useful for imbalanced datasets because ROC curve makes use of True Negatives in the False Positive Rate while it is avoided in the Precision-Recall curve.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_model(model, data, balanced=True):\n",
    "    \n",
    "    preds = model.transform(data)\n",
    "    y_preds = preds.select('prediction').rdd.keys().collect()\n",
    "    y_score = preds.select(vector_to_array(\"probability\")[1]).rdd.keys().collect()\n",
    "    y = preds.select(\"is_fraud\").rdd.keys().collect()\n",
    "    if balanced:\n",
    "        fpr, tpr, _ = roc_curve(y, y_score)\n",
    "        print(f\"ROC area under curve Score: {roc_auc_score(y, y_score)}\")\n",
    "    prec, recall, _ = precision_recall_curve(y, y_score)    \n",
    "    cm = confusion_matrix(y, y_preds)\n",
    "    pr = np.array([prec, recall]).T\n",
    "    pr = pr[pr[:,0].argsort()]\n",
    "    print(f\"PR area under curve Score: {auc(pr[:,0], pr[:,1])}\")\n",
    "    print(f\"Confusion Matrix:\")\n",
    "    print(cm)\n",
    "    if balanced:\n",
    "        roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot()\n",
    "    pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot()\n",
    "    cm_display = ConfusionMatrixDisplay(confusion_matrix=cm).plot()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To evaluate 'real-life' performance, the scoring dataset is used. Classes in that dataset are not balanced.\n",
    "\n",
    "Make sure to consider this fact when looking at the numbers, especially when looking at the confusion matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "scoring_file_pattern = 'scoring set/medium/*male*.csv'\n",
    "scoring_df = sc.read.option(\"delimiter\", \"|\").csv(data_folder + scoring_file_pattern, header=True, inferSchema=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extra features are created and all features are then encoded for that dataset, using the encoding pipeline created earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_df = create_feature_columns(scoring_df)\n",
    "scoring_df = encode_features(scoring_df, pipeline_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"model_selection\"></a>\n",
    "## 1.6. Model Selection\n",
    "\n",
    "Here you will train a selection of models on the sample dataset to find the best performing solution.\n",
    "\n",
    "Unfortunately, with Spark models, it is not possible to use the automl features of the oracle ads module, so models are trained and evaluated individually.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"lr\"></a>\n",
    "### 1.6.1. Logistic Regression Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "22/06/24 22:33:10 WARN BLAS: Failed to load implementation from: com.github.fommil.netlib.NativeSystemBLAS\n",
      "22/06/24 22:33:10 WARN BLAS: Failed to load implementation from: com.github.fommil.netlib.NativeRefBLAS\n"
     ]
    }
   ],
   "source": [
    "c_lr = LogisticRegression(featuresCol='features', labelCol='is_fraud')\n",
    "model_lr = c_lr.fit(train_downsampled)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the trained Logistic Regression model on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 332:=================================================>     (18 + 2) / 20]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC area under curve Score: 0.8780187542563781\n",
      "PR area under curve Score: 0.6236784673673683\n",
      "Confusion Matrix:\n",
      "[[906   3]\n",
      " [ 48  36]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_lr, test_downsampled, balanced=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the model on the scoring set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PR area under curve Score: 0.3180304857271028\n",
      "Confusion Matrix:\n",
      "[[1725114   11981]\n",
      " [   5104    4416]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_lr, scoring_df, balanced=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model performs OK on the balanced training set, but its performance drops quite significantly when looking at the unbalanced scoring set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"dt\"></a>\n",
    "### 1.6.2. Decision Tree Classifier Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "c_dt = DecisionTreeClassifier(featuresCol='features', labelCol='is_fraud')\n",
    "model_dt = c_dt.fit(train_downsampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC area under curve Score: 0.9408036041699408\n",
      "PR area under curve Score: 0.5827688706344346\n",
      "Confusion Matrix:\n",
      "[[897  12]\n",
      " [ 25  59]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_dt, test_downsampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PR area under curve Score: 0.40825176281792597\n",
      "Confusion Matrix:\n",
      "[[1709750   27345]\n",
      " [   2939    6581]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_dt, scoring_df, balanced=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model performs better on the scoring set, although it performed worse on the test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"rf\"></a>\n",
    "### 1.6.3. Random Forest Classifier\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "c_rf = RandomForestClassifier(featuresCol='features', labelCol='is_fraud')\n",
    "model_rf = c_rf.fit(train_downsampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 376:=================================================>     (18 + 2) / 20]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC area under curve Score: 0.9611949290167112\n",
      "PR area under curve Score: 0.7485288201166327\n",
      "Confusion Matrix:\n",
      "[[907   2]\n",
      " [ 37  47]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_rf, test_downsampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PR area under curve Score: 0.5050344848419276\n",
      "Confusion Matrix:\n",
      "[[1730662    6433]\n",
      " [   4078    5442]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_rf, scoring_df, balanced=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Random Forest model performs significantly better on both the test and scoring sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"gbt\"></a>\n",
    "### 1.6.4. Gradient Boosted Trees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# set log level to ERROR to suppress local Spark heap memory warnings.\n",
    "sc.sparkContext.setLogLevel(\"ERROR\")\n",
    "c_gbt = GBTClassifier(featuresCol='features', labelCol='is_fraud')\n",
    "model_gbt = c_gbt.fit(train_downsampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC area under curve Score: 0.9657590759075907\n",
      "PR area under curve Score: 0.7365834854812544\n",
      "Confusion Matrix:\n",
      "[[901   8]\n",
      " [ 29  55]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_gbt, test_downsampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PR area under curve Score: 0.44523765999295356\n",
      "Confusion Matrix:\n",
      "[[1718765   18330]\n",
      " [   2742    6778]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "eval_model(model_gbt, scoring_df, balanced=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Gradient Boosted Tree classsifier performs better on the test set and slightly worse on the unbalanced scoring set. Note that the rate of false negative is also the lowest, so this model seems promising to train further on a larger dataset.\n",
    "\n",
    "The Random Forest classifier is another good option here. Swapping out the model type is trivial in the code that follows, so it is left as an exercise to the reader."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"df_training\"></a>\n",
    "## 7. Running Training on OCI Data Flow\n",
    "\n",
    "To run the training on the OCI Data Flow service, the application code is put together into a single script.\n",
    "\n",
    "All the helper functions developed previously will be aggregated into a single cell, with the `main` function taking input parameters. This cell will be saved as a file to create the Data Flow application using the `%%writefile` Jupyter magic.\n",
    "\n",
    "The DataFlow ads module uses a base folder to store the files needed to send to the Data Flow service. To test the code locally, the code module should be importable from the notebook, so it must be available from the local folder, to make this possible, the base folder is defined relative to the current path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataflow_basefolder = os.path.join(os.getcwd(), 'dataflow')\n",
    "if not os.path.exists(dataflow_basefolder):\n",
    "    os.makedirs(dataflow_basefolder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"training_script\"></a>\n",
    "### 7.1. Data Flow Training Application script\n",
    "\n",
    "In the code, the data transformation and model training are folded into a single pipeline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing /home/datascience/workspace/notebooks/dataflow/fraud_detection_model_training.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile {dataflow_basefolder}/fraud_detection_model_training.py\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# Importing pyspark libraries\n",
    "from pyspark.conf import SparkConf\n",
    "from pyspark.ml import Pipeline\n",
    "from pyspark.ml.classification import GBTClassifier\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql.types import FloatType\n",
    "\n",
    "\n",
    "def get_spark_session(app_name, file_location=None, profile_name=None, spark_config={}):\n",
    "\n",
    "    spark_builder = SparkSession.builder.appName(app_name)\n",
    "\n",
    "    # Add in extra configuration.\n",
    "    for key, val in spark_config.items():\n",
    "        spark_builder.config(key, val)\n",
    "\n",
    "    # Create the Spark session.\n",
    "    session = spark_builder.getOrCreate()\n",
    "    return session\n",
    "\n",
    "\n",
    "def distance(lat, long, merchant_lat, merchant_long):\n",
    "\n",
    "    # approximate radius of earth in km\n",
    "    R = 6373.0\n",
    "\n",
    "    s_lat = np.deg2rad(float(lat))                      \n",
    "    s_lng = np.deg2rad(float(long))     \n",
    "    e_lat = np.deg2rad(float(merchant_lat))                       \n",
    "    e_lng = np.deg2rad(float(merchant_long))  \n",
    "\n",
    "    d = np.sin((e_lat - s_lat) / 2)**2 + np.cos(s_lat) * np.cos(e_lat) * np.sin((e_lng - s_lng) / 2)**2\n",
    "\n",
    "    return float(2 * R * np.arcsin(np.sqrt(d)))\n",
    "\n",
    "\n",
    "def create_feature_columns(df):\n",
    "    # Augments the dataset with features we identified\n",
    "    \n",
    "    # drop unneeded columns\n",
    "    df = df.drop('ssn', 'cc_num', 'first', 'last', 'street', 'city', 'state', \n",
    "                 'zip', 'job', 'acct_num', 'profile', 'trans_num', 'unix_time', \n",
    "                 'merchant')\n",
    "\n",
    "    # transaction date and time features\n",
    "    df = df.withColumn('day_of_week', dayofweek(col('trans_date')))\n",
    "    df = df.withColumn('month_of_year', month(col('trans_date')))\n",
    "    df = df.withColumn('hour_of_day', hour(col('trans_time')))\n",
    "    df = df.withColumn('is_weekend', col('day_of_week').isin([1,7]).cast('int'))\n",
    "    \n",
    "    # distance\n",
    "    distance_udf = udf(lambda lat, long, merch_lat, merch_long: distance(lat, long, merch_lat, merch_long), FloatType())\n",
    "    df = df.withColumn(\"distance\", distance_udf(col('lat'), col('long'), col('merch_lat'), col('merch_long')))\n",
    "    \n",
    "    # customer age and gender\n",
    "    df = df.withColumn('age', floor(datediff(col('trans_date'), to_date(col('dob'), 'yyyy-mm-dd'))/365.25))\n",
    "    df = df.withColumn('gender', when((col('gender') == 'M'), 1).when((col('gender') == 'F'), 0).otherwise(-1))\n",
    "    \n",
    "    # drop no longer used columns\n",
    "    df = df.drop('dob', 'trans_date', 'trans_time')\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "def create_and_fit_model(df):\n",
    "    # Create a pipeline model encoding categorica features\n",
    "    # which can be re-used to evaluate the model\n",
    "    \n",
    "    # 1-hot encode merchant category\n",
    "    stringIndexer = StringIndexer(inputCol='category', outputCol='category_index')\n",
    "    encoder = OneHotEncoder(inputCols=[stringIndexer.getOutputCol()], outputCols=['category_classVec'])\n",
    "    \n",
    "    # assemble the feature vector with all numerical columns and the category 1-hot encoded column\n",
    "    numeric_columns = [col[0] for col in df.dtypes if col[1] in ['int', 'double'] and col[0] != 'is_fraud']\n",
    "    assembler_inputs = ['category_classVec'] + numeric_columns\n",
    "    assembler = VectorAssembler(inputCols=assembler_inputs, outputCol=\"features\")\n",
    "\n",
    "    # define the model\n",
    "    c_gbt = GBTClassifier(featuresCol='features', labelCol='is_fraud', maxDepth=15, maxIter=20, stepSize=0.05)\n",
    "    \n",
    "    # line up the stages for the whole process\n",
    "    stages = [stringIndexer, encoder, assembler, c_gbt]\n",
    "    \n",
    "    # put together the pipeline and fit it\n",
    "    pipeline = Pipeline(stages=stages)\n",
    "    pipeline_model = pipeline.fit(df)\n",
    "    return pipeline_model\n",
    "\n",
    "\n",
    "def main(input_data_path, model_output_path, debug, spark_config={}):\n",
    "    \n",
    "    sc = get_spark_session(app_name='Fraud Detection Model Training', spark_config=spark_config)\n",
    "    sc.conf.set(\"spark.sql.legacy.timeParserPolicy\",\"LEGACY\")\n",
    "    df = sc.read.option(\"delimiter\", \"|\").csv(input_data_path, header=True, inferSchema=True)\n",
    "\n",
    "    df = create_feature_columns(df)\n",
    "\n",
    "    # split into train and test sets\n",
    "    train, test = df.randomSplit([0.8, 0.2], seed = 2018)\n",
    "    \n",
    "    # downsample the majority class\n",
    "    train_downsampled = train.sampleBy('is_fraud', fractions = {1: 1, 0: 0.05}, seed= 1234)\n",
    "\n",
    "    # fit and train the model\n",
    "    model = create_and_fit_model(train_downsampled)\n",
    "    \n",
    "    # write the fitted model to file to use for inference\n",
    "    model.write().overwrite().save(model_output_path)\n",
    "    \n",
    "    if debug == True:\n",
    "        predictions = model.transform(test)\n",
    "        predictions.select('age', 'is_fraud', 'rawPrediction', 'prediction', 'probability').show(50)\n",
    "        evaluator = BinaryClassificationEvaluator(labelCol='is_fraud')\n",
    "        print(\"Test Area Under ROC: \" + str(evaluator.evaluate(predictions, {evaluator.metricName: \"areaUnderROC\"})))\n",
    "\n",
    "            \n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    input_data_path = sys.argv[1]\n",
    "    model_output_path = sys.argv[2]\n",
    "    debug = False\n",
    "    if sys.argv[3].lower() == 'true':\n",
    "        debug = True\n",
    "\n",
    "    main(input_data_path, model_output_path, debug)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"test_training\"></a>\n",
    "### 7.2. Test the Data Flow Application script locally\n",
    "\n",
    "We can test the application locally by importing our file and running the main function, with proper input values.\n",
    "\n",
    "The next cell insures uses Jupyter magic syntax to insure the module created earlier is reloaded, so the code can be edited and tested again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%reload_ext autoreload"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next cell, the local module created above is loaded. In order for this to work, the folder used to save the file needs to be within the folder where this notebook runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataflow.fraud_detection_model_training import main"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An output path for the model files is defined in the next cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_output_path = 'output/model/small'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now call the `main` function with the required inputs. Specific `spark_config` parameters are also passed to avoid memory issues when running on the local Spark cluster in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---+--------+--------------------+----------+--------------------+\n",
      "|age|is_fraud|       rawPrediction|prediction|         probability|\n",
      "+---+--------+--------------------+----------+--------------------+\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507789205858...|       0.0|[0.93524246694145...|\n",
      "| 38|       0|[1.30702888503409...|       0.0|[0.93176085216755...|\n",
      "| 37|       0|[1.28199672003713...|       0.0|[0.92850799990702...|\n",
      "| 38|       0|[1.34295040690825...|       0.0|[0.93618953907972...|\n",
      "| 38|       0|[1.31293965612069...|       0.0|[0.93250867052638...|\n",
      "| 37|       0|[1.33402160106390...|       0.0|[0.93511440283102...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.30702888503409...|       0.0|[0.93176085216755...|\n",
      "| 38|       0|[1.31798995539058...|       0.0|[0.93314159395239...|\n",
      "| 38|       0|[1.27561700390310...|       0.0|[0.92765637265184...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 37|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33420217681248...|       0.0|[0.93513631241980...|\n",
      "| 38|       0|[1.33542724588581...|       0.0|[0.93528477060175...|\n",
      "| 38|       0|[1.23268525875029...|       0.0|[0.92167822593852...|\n",
      "| 38|       0|[1.33542557280759...|       0.0|[0.93528456806808...|\n",
      "| 38|       0|[1.33522104878229...|       0.0|[0.93525980506691...|\n",
      "| 38|       0|[1.29993995879175...|       0.0|[0.93085385095670...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.13432557915300...|       0.0|[0.90624724867271...|\n",
      "| 38|       0|[1.12010802986813...|       0.0|[0.90380324479685...|\n",
      "| 38|       0|[1.13432557915300...|       0.0|[0.90624724867271...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33507788920967...|       0.0|[0.93524246659636...|\n",
      "| 38|       0|[1.33049805056021...|       0.0|[0.93468550340351...|\n",
      "+---+--------+--------------------+----------+--------------------+\n",
      "only showing top 50 rows\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Area Under ROC: 0.9715829788994192\n"
     ]
    }
   ],
   "source": [
    "main(os.path.join(data_folder, file_pattern), model_output_path, debug=True, \n",
    "        spark_config={\n",
    "            'spark.driver.memory': '512g', \n",
    "            'spark.executor.memory': '512g'\n",
    "        })\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"training_app\"></a>\n",
    "### 7.3. Create the Data Flow Application\n",
    "\n",
    "The Oracle ADS package provides simple wrapper functions to create Data Flow applications and associated Runs.\n",
    "\n",
    "Resource principal is used to authenticate. If your notebook uses an API key, change the auth to `api_key`. On a local machine use your OCI config or API key for auth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:root:~/.oci/config file not exists, default value oci.config.DEFAULT_LOCATION used instead\n"
     ]
    }
   ],
   "source": [
    "ads.set_auth(auth='resource_principal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Data Flow base folder needs to be passed specifically, so application and run files will be saved there, and picked up from there when editing.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are now providing input parameters pointing to the files on Object Storage, so the Data Flow application can reach them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyspark_file_path = f'{dataflow_basefolder}/fraud_detection_model_training.py'\n",
    "\n",
    "# If you have generated and stored the xlarge dataset on Object Storage, you can set this parameter to xlarge\n",
    "# dataset_size = 'xlarge'\n",
    "dataset_size = 'medium'\n",
    "input_data_path = f'oci://{data_bucket_name}@{tenancy_namespace}/training set/{dataset_size}/*male*.csv'\n",
    "model_output_path = f'oci://{data_bucket_name}@{tenancy_namespace}/output/{dataset_size}/model'\n",
    "debug = 'true'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now prepare the Data Flow application with the `prepare_app` function:\n",
    "\n",
    "- `arguments` is a list of arguments passed to the program as if it was run on command line so we pass the variables names defined in script_parameters.\n",
    "\n",
    "- `script_parameters` contains the default values for these variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_app_config = data_flow.prepare_app(\n",
    "                        display_name=\"Fraud Detection Model Training\",\n",
    "                        script_bucket=code_bucket_name,\n",
    "                        pyspark_file_path=pyspark_file_path,\n",
    "                        logs_bucket=logs_bucket_name,\n",
    "                        spark_version='3.0.2',\n",
    "                        arguments=[\n",
    "                            \"${input_data_path}\", \n",
    "                            \"${model_output_path}\", \n",
    "                            \"${debug}\"\n",
    "                        ],\n",
    "                        script_parameters={\n",
    "                         'input_data_path': input_data_path,\n",
    "                         'model_output_path': model_output_path,\n",
    "                         'debug': debug\n",
    "                        })\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now create the Data Flow application:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:ads.common:You have a file with the same key in your bucket on object storage. It will be overwritten per your request.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "loop1:   0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "training_app = data_flow.create_app(training_app_config, overwrite_script=True, overwrite_archive=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To look up an existing app, use the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:root:~/.oci/config file not exists, default value oci.config.DEFAULT_LOCATION used instead\n"
     ]
    },
    {
     "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>display_name</th>\n",
       "      <th>id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Fraud Detection Model Training</td>\n",
       "      <td>ocid1.dataflowapplication.oc1.phx.anyhqljtnif7xwiawgunxarvzvhrg5pyyn46wamgocdaofikyrw7arqlyaga</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     display_name  \\\n",
       "0  Fraud Detection Model Training   \n",
       "\n",
       "                                                                                               id  \n",
       "0  ocid1.dataflowapplication.oc1.phx.anyhqljtnif7xwiawgunxarvzvhrg5pyyn46wamgocdaofikyrw7arqlyaga  "
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ads.set_auth(auth='resource_principal')\n",
    "data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)\n",
    "pd.DataFrame(json.loads(str(data_flow.list_apps())))[['display_name', 'id']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next section, you will launch a Data Flow run. If you only wanted to launch a new run on an existing app, skip the app creation part above, look up the app ID, and use the code in the following cell, replacing the id in the `load_app` function to reload the app."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ads.set_auth(auth='resource_principal')\n",
    "# data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)\n",
    "# training_app = data_flow.load_app(<app_id>)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"training_run\"></a>\n",
    "### 7.4. Create a Data Flow Training Run\n",
    "\n",
    "The app was created with default input parameters. At run-time, these parameters can be modified by passing them as arguments to the prepare_run function (commented out here):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_run_config = training_app.prepare_run(run_display_name=f\"Fraud Detection Model Training demo\",\n",
    "                             num_executors=12,\n",
    "                             driver_shape='VM.Standard2.16',\n",
    "                             executor_shape='VM.Standard2.16',\n",
    "                             # optional parameters overrides\n",
    "#                              input_data_path='<new_path_to_input_dataset>',\n",
    "#                              model_output_path= '<new_path_to_save_the_model>',\n",
    "#                              debug=True\n",
    "                            )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally you can launch the run.\n",
    "\n",
    "The `wait` flag defines if the code should wait for the run to complete. A run on the medium set may take several minutes, and a run on the xlarge dataset would take several hours. The function authentication tends to time out after 30 minutes, so for large runs it is typically recommended to check the status in the OCI console."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:root:~/.oci/config file not exists, default value oci.config.DEFAULT_LOCATION used instead\n"
     ]
    }
   ],
   "source": [
    "ads.set_auth(auth='resource_principal')\n",
    "data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)\n",
    "training_run = training_app.run(training_run_config, save_log_to_local=True, wait=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"edit_script\"></a>\n",
    "### 7.5. Editing Data Flow applications\n",
    "\n",
    "You can edit the script, run the script cell to save the script locally, and come back to the cell above to create a new run. The script will be automatically synced into Object Storage before the run starts.\n",
    "\n",
    "Please note that the `%%writefile` magic tends to take a few seconds to update the script locally, so take a short pause before re-running the cell above to insure the latest code gets synced up.\n",
    "\n",
    "<a id=\"df_scoring\"></a>\n",
    "## 8. Create a Batch Scoring Application\n",
    "\n",
    "<a id=\"scoring_script\"></a>\n",
    "### 8.1. Data Flow Batch Scoring Application script\n",
    "\n",
    "In the following cell, the script for batch scoring or inference is put together in a single cell, just like for the training script. Note that this time the model pipeline is loaded, which performs all the steps (feature building, vector assembly) and then the `transform` method is called on the pipeline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing /home/datascience/workspace/notebooks/dataflow/fraud_detection_batch_scoring.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile {dataflow_basefolder}/fraud_detection_batch_scoring.py\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# Importing pyspark libraries\n",
    "from pyspark.conf import SparkConf\n",
    "from pyspark.ml import PipelineModel\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql.types import FloatType\n",
    "\n",
    "    \n",
    "def get_spark_session(app_name, file_location=None, profile_name=None, spark_config={}):\n",
    "\n",
    "    spark_builder = SparkSession.builder.appName(app_name)\n",
    "        \n",
    "    # Add in extra configuration.\n",
    "    for key, val in spark_config.items():\n",
    "        spark_builder.config(key, val)\n",
    "\n",
    "    # Create the Spark session.\n",
    "    session = spark_builder.getOrCreate()\n",
    "    return session\n",
    "\n",
    "\n",
    "def distance(lat, long, merchant_lat, merchant_long):\n",
    "\n",
    "    # approximate radius of earth in km\n",
    "    R = 6373.0\n",
    "\n",
    "    s_lat = np.deg2rad(float(lat))                      \n",
    "    s_lng = np.deg2rad(float(long))     \n",
    "    e_lat = np.deg2rad(float(merchant_lat))                       \n",
    "    e_lng = np.deg2rad(float(merchant_long))  \n",
    "\n",
    "    d = np.sin((e_lat - s_lat) / 2)**2 + np.cos(s_lat) * np.cos(e_lat) * np.sin((e_lng - s_lng) / 2)**2\n",
    "\n",
    "    return float(2 * R * np.arcsin(np.sqrt(d)))\n",
    "\n",
    "\n",
    "def create_feature_columns(df):\n",
    "    # Augments the dataset with features we identified\n",
    "    \n",
    "    # for scoring, we don't drop the original columns: \n",
    "    # we may want the original columns in the final output.\n",
    "    # Columns we need will be picked up by the pipeline\n",
    "    \n",
    "    # transaction date and time features\n",
    "    df = df.withColumn('day_of_week', dayofweek(col('trans_date')))\n",
    "    df = df.withColumn('month_of_year', month(col('trans_date')))\n",
    "    df = df.withColumn('hour_of_day', hour(col('trans_time')))\n",
    "    df = df.withColumn('is_weekend', col('day_of_week').isin([1,7]).cast('int'))\n",
    "    \n",
    "    # distance\n",
    "    distance_udf = udf(lambda lat, long, merch_lat, merch_long: distance(lat, long, merch_lat, merch_long), FloatType())\n",
    "    df = df.withColumn(\"distance\", distance_udf(col('lat'), col('long'), col('merch_lat'), col('merch_long')))\n",
    "    \n",
    "    # customer age and gender\n",
    "    df = df.withColumn('age', floor(datediff(col('trans_date'), to_date(col('dob'), 'yyyy-mm-dd'))/365.25))\n",
    "    df = df.withColumn('gender', when((col('gender') == 'M'), 1).when((col('gender') == 'F'), 0).otherwise(-1))\n",
    "    \n",
    "    return df\n",
    "\n",
    "\n",
    "def main(input_data_path, model_path, predictions_output_path, debug, spark_config={}):\n",
    "    \n",
    "    # create the session\n",
    "    sc = get_spark_session(app_name='Fraud Detection Model Training', spark_config=spark_config)\n",
    "    sc.conf.set(\"spark.sql.legacy.timeParserPolicy\",\"LEGACY\")\n",
    "    \n",
    "    # load the data\n",
    "    df = sc.read.option(\"delimiter\", \"|\").csv(input_data_path, header=True, inferSchema=True)\n",
    "    original_cols = df.columns\n",
    "\n",
    "    print(\"Dataset Count: \" + str(df.count()))\n",
    "\n",
    "    # augment the dat with tnew columns\n",
    "    df = create_feature_columns(df)\n",
    "    \n",
    "    # load the model\n",
    "    # edit\n",
    "    model = PipelineModel.load(model_path)\n",
    "\n",
    "    # predict\n",
    "    predictions = model.transform(df)\n",
    "    \n",
    "    # show some results\n",
    "    predictions.select('age', 'is_fraud', 'rawPrediction', 'prediction', 'probability').show(50)\n",
    "    evaluator = BinaryClassificationEvaluator(labelCol='is_fraud')\n",
    "    print(\"Test Area Under ROC: \" + str(evaluator.evaluate(predictions, {evaluator.metricName: \"areaUnderROC\"})))\n",
    "    predictions.printSchema()\n",
    "    predictions = predictions.select(original_cols + ['prediction'])\n",
    "    predictions.write.format('com.databricks.spark.csv').mode('overwrite').option(\"header\", \"true\").save(predictions_output_path)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    input_data_path = sys.argv[1]\n",
    "    model_path = sys.argv[2]\n",
    "    predictions_output_path = sys.argv[3]\n",
    "    debug = False\n",
    "    if sys.argv[4].lower() == 'true':\n",
    "        debug = True\n",
    "\n",
    "    main(input_data_path, model_path, predictions_output_path, debug)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyspark_file_path = f'{dataflow_basefolder}/fraud_detection_batch_scoring.py'\n",
    "\n",
    "# Note the inference dataset should be different from the training set\n",
    "inference_dataset_size = 'small'\n",
    "input_data_path = f'oci://{data_bucket_name}@{tenancy_namespace}/training set/{inference_dataset_size}/*male*.csv'\n",
    "\n",
    "predictions_output_path = f'oci://{data_bucket_name}@{tenancy_namespace}/output/{inference_dataset_size}/predictions/predictions.csv'\n",
    "debug = 'true'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:root:~/.oci/config file not exists, default value oci.config.DEFAULT_LOCATION used instead\n"
     ]
    }
   ],
   "source": [
    "ads.set_auth(auth='resource_principal')\n",
    "data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_app_config = data_flow.prepare_app(\n",
    "                        display_name=\"Fraud Detection Batch Scoring\",\n",
    "                        script_bucket=code_bucket_name,\n",
    "                        pyspark_file_path=pyspark_file_path,\n",
    "                        logs_bucket=logs_bucket_name,\n",
    "                        spark_version='3.0.2',\n",
    "                        arguments=[\n",
    "                            \"${input_data_path}\", \n",
    "                            \"${model_path}\", \n",
    "                            \"${predictions_output_path}\",\n",
    "                            \"${debug}\"\n",
    "                        ],\n",
    "                        script_parameters={\n",
    "                         'input_data_path': input_data_path,\n",
    "                         'model_path': model_output_path,\n",
    "                         'predictions_output_path': predictions_output_path,\n",
    "                         'debug': debug\n",
    "                        })\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:ads.common:You have a file with the same key in your bucket on object storage. It will be overwritten per your request.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "loop1:   0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "scoring_app = data_flow.create_app(scoring_app_config, overwrite_script=True, overwrite_archive=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also load an existing app by looking up its id, then running `load_app`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:root:~/.oci/config file not exists, default value oci.config.DEFAULT_LOCATION used instead\n"
     ]
    },
    {
     "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>display_name</th>\n",
       "      <th>id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Fraud Detection Batch Scoring</td>\n",
       "      <td>ocid1.dataflowapplication.oc1.phx.anyhqljsnif7xwiaqd4eksues45tdoncfcxbgubcplmnv46reqlxujltxmwa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Fraud Detection Model Training</td>\n",
       "      <td>ocid1.dataflowapplication.oc1.phx.anyhqljtnif7xwiawgunxarvzvhrg5pyyn46wamgocdaofikyrw7arqlyaga</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     display_name  \\\n",
       "0   Fraud Detection Batch Scoring   \n",
       "1  Fraud Detection Model Training   \n",
       "\n",
       "                                                                                               id  \n",
       "0  ocid1.dataflowapplication.oc1.phx.anyhqljsnif7xwiaqd4eksues45tdoncfcxbgubcplmnv46reqlxujltxmwa  \n",
       "1  ocid1.dataflowapplication.oc1.phx.anyhqljtnif7xwiawgunxarvzvhrg5pyyn46wamgocdaofikyrw7arqlyaga  "
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ads.set_auth(auth='resource_principal')\n",
    "data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)\n",
    "pd.DataFrame(json.loads(str(data_flow.list_apps())))[['display_name', 'id']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"scoring_run\"></a>\n",
    "### 8.2. Create a Data Flow Run for scoring\n",
    "\n",
    "The run is prepared the same way the training run was prepared. At run-time, you again have the opportunity to override input parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_run_config = scoring_app.prepare_run(run_display_name=f\"Fraud Detection Batch Scoring - demo\",\n",
    "                             num_executors=2,\n",
    "                             driver_shape='VM.Standard2.16',\n",
    "                             executor_shape='VM.Standard2.16',\n",
    "                             # optional parameter overrides\n",
    "#                              input_data_path='<new_path_to_input_data>',\n",
    "#                              model_path= '<path_to_model_on_object_storage>',\n",
    "#                              predictions_output_path=f'<output_path_for_predictions>',\n",
    "#                              debug=True\n",
    "                            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_run = scoring_app.run(scoring_run_config, save_log_to_local=True, wait=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"model_cat\"></a> \n",
    "## 9. Create a Model in Model Catalog\n",
    "\n",
    "<a id=\"artifact\"></a>\n",
    "### 9.1. Prepare the Model Artifact for Model Catalog\n",
    "\n",
    "Artifacts require a local folder to store files. In the next few cells, the default `score.py` file will be overwritten by the inference script, and the Spark model files will imported into this folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_to_artifact = f\"./fraud-detection-model-deployment\"\n",
    "if not os.path.exists(path_to_artifact):\n",
    "    os.makedirs(path_to_artifact)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:ads.common:model not found in /home/datascience/workspace/notebooks/fraud-detection-model-deployment. Save the serialized model under /home/datascience/workspace/notebooks/fraud-detection-model-deployment.\n",
      "INFO:ADS:To auto-extract taxonomy metadata the model must be provided. Supported models: automl, keras, lightgbm, pytorch, sklearn, tensorflow, and xgboost.\n"
     ]
    }
   ],
   "source": [
    "model = GenericModel(estimator=None, \n",
    "                    auth=ads.common.auth.resource_principal(),\n",
    "                    model_file_name=\"model\",\n",
    "                    serialize=False,\n",
    "                    artifact_dir=path_to_artifact\n",
    "                )\n",
    "\n",
    "model.prepare(model_file_name=\"model\",\n",
    "              inference_conda_env='pyspark30_p37_cpu_v4', \n",
    "              inference_python_version='3.7',\n",
    "              force_overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"model_script\"></a>\n",
    "### 9.2. Create the Inference Model script\n",
    "\n",
    "Saving the script with the `%%writefile` magic overwrites the `score.py` file in the artifact folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting ./fraud-detection-model-deployment/score.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile {path_to_artifact}/score.py\n",
    "\n",
    "import json\n",
    "import numpy as np\n",
    "import ocifs\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# Importing pyspark libraries\n",
    "from pyspark.ml import PipelineModel\n",
    "from pyspark.ml.classification import GBTClassificationModel\n",
    "from pyspark.ml.evaluation import BinaryClassificationEvaluator\n",
    "from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql.types import FloatType\n",
    "\n",
    "\n",
    "model_file = 'model'\n",
    "\n",
    "sc = SparkSession \\\n",
    "    .builder \\\n",
    "    .appName('Fraud Detection Inference') \\\n",
    "    .config('spark.driver.memory', '64g') \\\n",
    "    .config('spark.executor.memory', '64g') \\\n",
    "    .getOrCreate()\n",
    "\n",
    "fs = ocifs.OCIFileSystem()\n",
    "\n",
    "def distance(lat, long, merchant_lat, merchant_long):\n",
    "\n",
    "    # approximate radius of earth in km\n",
    "    R = 6373.0\n",
    "\n",
    "    s_lat = np.deg2rad(float(lat))                      \n",
    "    s_lng = np.deg2rad(float(long))     \n",
    "    e_lat = np.deg2rad(float(merchant_lat))                       \n",
    "    e_lng = np.deg2rad(float(merchant_long))  \n",
    "\n",
    "    d = np.sin((e_lat - s_lat) / 2)**2 + np.cos(s_lat) * np.cos(e_lat) * np.sin((e_lng - s_lng) / 2)**2\n",
    "\n",
    "    return float(2 * R * np.arcsin(np.sqrt(d)))\n",
    "\n",
    "\n",
    "def create_feature_columns(df):\n",
    "    # Augments the dataset with features we identified\n",
    "        \n",
    "    # transaction date and time features\n",
    "    df = df.withColumn('day_of_week', dayofweek(col('trans_date')))\n",
    "    df = df.withColumn('month_of_year', month(col('trans_date')))\n",
    "    df = df.withColumn('hour_of_day', hour(col('trans_time')))\n",
    "    df = df.withColumn('is_weekend', col('day_of_week').isin([1,7]).cast('int'))\n",
    "    \n",
    "    # distance\n",
    "    distance_udf = udf(lambda lat, long, merch_lat, merch_long: distance(lat, long, merch_lat, merch_long), FloatType())\n",
    "    df = df.withColumn(\"distance\", distance_udf(col('lat'), col('long'), col('merch_lat'), col('merch_long')))\n",
    "    \n",
    "    # customer age and gender\n",
    "    df = df.withColumn('age', floor(datediff(col('trans_date'), to_date(col('dob'), 'yyyy-mm-dd'))/365.25))\n",
    "    df = df.withColumn('gender', when((col('gender') == 'M'), 1).when((col('gender') == 'F'), 0).otherwise(-1))\n",
    "    \n",
    "    return df\n",
    "\n",
    "\n",
    "def load_model():\n",
    "    \"\"\"\n",
    "    Loads model from the serialized format\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    model:  a model instance on which predict API can be invoked\n",
    "    \"\"\"\n",
    "    \n",
    "    # Load config file\n",
    "    model_dir = os.path.dirname(os.path.realpath(__file__))\n",
    "    contents = os.listdir(model_dir)\n",
    "    if model_file in contents:\n",
    "        model = PipelineModel.load(os.path.join(model_dir, model_file))\n",
    "        return model\n",
    "    else:\n",
    "        raise Exception('{0} is not found in model directory {1}'.format(config_file, model_dir))\n",
    "    \n",
    "\n",
    "\n",
    "def predict(data, model=load_model()) -> dict:\n",
    "    \"\"\"\n",
    "    Returns prediction given the model and data to predict\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model: Model instance returned by load_model API\n",
    "    data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Panda DataFrame\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    predictions: Output from scoring server\n",
    "        Format: { 'prediction': output from `model.predict` method }\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # if the data is a single datapoint, wrap it into an array\n",
    "    if not isinstance(data, list):\n",
    "        data = [data]\n",
    "\n",
    "    # load the data into a Spark dataframe\n",
    "    df = sc.read.json(sc.sparkContext.parallelize(data))\n",
    "    df_cols = df.columns\n",
    "\n",
    "    print(\"Dataset Count: \" + str(df.count()))\n",
    "\n",
    "    # create the features and get predictions\n",
    "    df = create_feature_columns(df)\n",
    "    predictions = model.transform(df)\n",
    "    # output original columns and the prediction column, dropping other stats that are vectors \n",
    "    # and don't serialize when using toJSON\n",
    "    results = predictions.select(df_cols + ['prediction']).toJSON().map(json.loads).collect()\n",
    "    \n",
    "    # return the response to the request\n",
    "    return {'predictions': results}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"pull_model\"></a>\n",
    "### 9.3. Get the trained model into the model deployment folder\n",
    "\n",
    "Next the model generated with the Spark run and saved to object storage needs to be pulled and saved into our model folder. \n",
    "\n",
    "To do this, load it and then save it locally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "sc = get_spark_session(app_name='test')\n",
    "spark_model = PipelineModel.load(model_output_path)\n",
    "spark_model.write().overwrite().save(f'{path_to_artifact}/model')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"save_to_cat\"></a>\n",
    "### 9.4. Save the model into Model Catalog\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-24 22:39:47,733 - ocifs - INFO - Setting up OCI Connection.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:ocifs:Setting up OCI Connection.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-24 22:39:48,523 - ocifs - INFO - Object Storage Client is being set up using resource_principal principal.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:ocifs:Object Storage Client is being set up using resource_principal principal.\n",
      "['model', 'score.py', 'runtime.yaml']\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "loop1:   0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "artifact:/tmp/saved_model_30a21875-5e88-4b3a-81c9-d52c8e6db035.zip\n"
     ]
    }
   ],
   "source": [
    "model_id = model.save(display_name='fraud-detection-model-demo',\n",
    "              description='Fraud Detection Model Deployment Demo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"test_model\"></a>\n",
    "### 9.5. Test the model locally\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get some sample data from the small dataset to test the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Count: 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "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>acct_num</th>\n",
       "      <th>amt</th>\n",
       "      <th>category</th>\n",
       "      <th>cc_num</th>\n",
       "      <th>city</th>\n",
       "      <th>city_pop</th>\n",
       "      <th>dob</th>\n",
       "      <th>first</th>\n",
       "      <th>gender</th>\n",
       "      <th>is_fraud</th>\n",
       "      <th>...</th>\n",
       "      <th>profile</th>\n",
       "      <th>ssn</th>\n",
       "      <th>state</th>\n",
       "      <th>street</th>\n",
       "      <th>trans_date</th>\n",
       "      <th>trans_num</th>\n",
       "      <th>trans_time</th>\n",
       "      <th>unix_time</th>\n",
       "      <th>zip</th>\n",
       "      <th>prediction</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>60.51</td>\n",
       "      <td>grocery_pos</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-23</td>\n",
       "      <td>fe1a26b8d4d6d904c823eddbde649479</td>\n",
       "      <td>08:03:39</td>\n",
       "      <td>1335168219</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>71.11</td>\n",
       "      <td>shopping_net</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-09-16</td>\n",
       "      <td>0b9e6299059906f5f9e0daa7df76dd62</td>\n",
       "      <td>05:30:19</td>\n",
       "      <td>1347773419</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>68.48</td>\n",
       "      <td>food_dining</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2013-03-19</td>\n",
       "      <td>504e5b7897a36d5ae3fda83565ffe2bc</td>\n",
       "      <td>00:34:03</td>\n",
       "      <td>1363653243</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>74.14</td>\n",
       "      <td>grocery_net</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-13</td>\n",
       "      <td>5e4569a5dae1c7aa11d04c7a7195321f</td>\n",
       "      <td>10:03:13</td>\n",
       "      <td>1334311393</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>52.62</td>\n",
       "      <td>grocery_pos</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-28</td>\n",
       "      <td>973e3642c75c14cd199a83108bd9fe09</td>\n",
       "      <td>11:05:46</td>\n",
       "      <td>1335611146</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       acct_num    amt      category           cc_num        city  city_pop  \\\n",
       "0  662887798281  60.51   grocery_pos  343926142939687  Harrisburg    165527   \n",
       "1  662887798281  71.11  shopping_net  343926142939687  Harrisburg    165527   \n",
       "2  662887798281  68.48   food_dining  343926142939687  Harrisburg    165527   \n",
       "3  662887798281  74.14   grocery_net  343926142939687  Harrisburg    165527   \n",
       "4  662887798281  52.62   grocery_pos  343926142939687  Harrisburg    165527   \n",
       "\n",
       "          dob first  gender  is_fraud  ...                      profile  \\\n",
       "0  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "1  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "2  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "3  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "4  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "\n",
       "           ssn  state           street  trans_date  \\\n",
       "0  674-05-2939     PA  185 Connor Fort  2012-04-23   \n",
       "1  674-05-2939     PA  185 Connor Fort  2012-09-16   \n",
       "2  674-05-2939     PA  185 Connor Fort  2013-03-19   \n",
       "3  674-05-2939     PA  185 Connor Fort  2012-04-13   \n",
       "4  674-05-2939     PA  185 Connor Fort  2012-04-28   \n",
       "\n",
       "                          trans_num trans_time   unix_time    zip prediction  \n",
       "0  fe1a26b8d4d6d904c823eddbde649479   08:03:39  1335168219  17110        0.0  \n",
       "1  0b9e6299059906f5f9e0daa7df76dd62   05:30:19  1347773419  17110        0.0  \n",
       "2  504e5b7897a36d5ae3fda83565ffe2bc   00:34:03  1363653243  17110        0.0  \n",
       "3  5e4569a5dae1c7aa11d04c7a7195321f   10:03:13  1334311393  17110        0.0  \n",
       "4  973e3642c75c14cd199a83108bd9fe09   11:05:46  1335611146  17110        0.0  \n",
       "\n",
       "[5 rows x 27 columns]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delta_data = pd.read_csv(f'{data_folder}/training set/small/adults_50up_male_urban_80-99.csv', delimiter='|')\n",
    "input_data = delta_data[15:20].to_json(orient='records')\n",
    "\n",
    "results = model.verify(data=input_data)\n",
    "pd.DataFrame(results['predictions']).head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"md\"></a>\n",
    "## 10. Deploy the model\n",
    "\n",
    "<a id=\"md_create\"></a>\n",
    "### 10.1 Create a Model Deployment and Endpoint\n",
    "\n",
    "To create the model deployment, simply call the `deploy` method of the GenericModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "loop1:   0%|          | 0/6 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "deployment = model.deploy(\n",
    "    display_name=\"Fraud Detection Model Deployment - demo\",\n",
    "    description=\"Fraud Detection Model Deployment - demo\",\n",
    "    deployment_instance_shape=\"VM.Standard2.1\",\n",
    "    deployment_instance_count=1,\n",
    "    # The following are optional\n",
    "#     deployment_access_log_id=\"<ACCESS_LOG_OCID>\",\n",
    "#     deployment_log_group_id=\"<LOG_GROUP_ID>\"\n",
    "#     predict_log_group_id=\"<PREDICT_LOG_GROUP_OCID>\",\n",
    "#     deployment_predict_log_id=\"<PREDICT_LOG_OCID>\",\n",
    "    wait_for_completion=True,\n",
    "    max_wait_time=600,\n",
    "    poll_interval=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The deployment endpoint url is available with the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://modeldeployment.us-phoenix-1.oci.customer-oci.com/ocid1.datasciencemodeldeployment.oc1.phx.amaaaaaanif7xwiaotxvrnsdnyuet3ret5f5lgligsyso3x72jymyhrmqysq'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deployment.url"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"test_md\"></a>\n",
    "### 10.2 Test the Model Deployment Endpoint\n",
    "\n",
    "The deployment can be tested easily using the `predict` method of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "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>acct_num</th>\n",
       "      <th>amt</th>\n",
       "      <th>category</th>\n",
       "      <th>cc_num</th>\n",
       "      <th>city</th>\n",
       "      <th>city_pop</th>\n",
       "      <th>dob</th>\n",
       "      <th>first</th>\n",
       "      <th>gender</th>\n",
       "      <th>is_fraud</th>\n",
       "      <th>...</th>\n",
       "      <th>profile</th>\n",
       "      <th>ssn</th>\n",
       "      <th>state</th>\n",
       "      <th>street</th>\n",
       "      <th>trans_date</th>\n",
       "      <th>trans_num</th>\n",
       "      <th>trans_time</th>\n",
       "      <th>unix_time</th>\n",
       "      <th>zip</th>\n",
       "      <th>prediction</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>60.51</td>\n",
       "      <td>grocery_pos</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-23</td>\n",
       "      <td>fe1a26b8d4d6d904c823eddbde649479</td>\n",
       "      <td>08:03:39</td>\n",
       "      <td>1335168219</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>71.11</td>\n",
       "      <td>shopping_net</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-09-16</td>\n",
       "      <td>0b9e6299059906f5f9e0daa7df76dd62</td>\n",
       "      <td>05:30:19</td>\n",
       "      <td>1347773419</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>68.48</td>\n",
       "      <td>food_dining</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2013-03-19</td>\n",
       "      <td>504e5b7897a36d5ae3fda83565ffe2bc</td>\n",
       "      <td>00:34:03</td>\n",
       "      <td>1363653243</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>74.14</td>\n",
       "      <td>grocery_net</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-13</td>\n",
       "      <td>5e4569a5dae1c7aa11d04c7a7195321f</td>\n",
       "      <td>10:03:13</td>\n",
       "      <td>1334311393</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>52.62</td>\n",
       "      <td>grocery_pos</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-28</td>\n",
       "      <td>973e3642c75c14cd199a83108bd9fe09</td>\n",
       "      <td>11:05:46</td>\n",
       "      <td>1335611146</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       acct_num    amt      category           cc_num        city  city_pop  \\\n",
       "0  662887798281  60.51   grocery_pos  343926142939687  Harrisburg    165527   \n",
       "1  662887798281  71.11  shopping_net  343926142939687  Harrisburg    165527   \n",
       "2  662887798281  68.48   food_dining  343926142939687  Harrisburg    165527   \n",
       "3  662887798281  74.14   grocery_net  343926142939687  Harrisburg    165527   \n",
       "4  662887798281  52.62   grocery_pos  343926142939687  Harrisburg    165527   \n",
       "\n",
       "          dob first  gender  is_fraud  ...                      profile  \\\n",
       "0  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "1  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "2  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "3  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "4  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "\n",
       "           ssn  state           street  trans_date  \\\n",
       "0  674-05-2939     PA  185 Connor Fort  2012-04-23   \n",
       "1  674-05-2939     PA  185 Connor Fort  2012-09-16   \n",
       "2  674-05-2939     PA  185 Connor Fort  2013-03-19   \n",
       "3  674-05-2939     PA  185 Connor Fort  2012-04-13   \n",
       "4  674-05-2939     PA  185 Connor Fort  2012-04-28   \n",
       "\n",
       "                          trans_num trans_time   unix_time    zip prediction  \n",
       "0  fe1a26b8d4d6d904c823eddbde649479   08:03:39  1335168219  17110        0.0  \n",
       "1  0b9e6299059906f5f9e0daa7df76dd62   05:30:19  1347773419  17110        0.0  \n",
       "2  504e5b7897a36d5ae3fda83565ffe2bc   00:34:03  1363653243  17110        0.0  \n",
       "3  5e4569a5dae1c7aa11d04c7a7195321f   10:03:13  1334311393  17110        0.0  \n",
       "4  973e3642c75c14cd199a83108bd9fe09   11:05:46  1335611146  17110        0.0  \n",
       "\n",
       "[5 rows x 27 columns]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = model.predict(data=input_data)\n",
    "pd.DataFrame(results['predictions']).head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To call the REST API with `requests`, use the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use resource principal authentication for the REST call\n",
    "auth = oci.auth.signers.get_resource_principals_signer()\n",
    "\n",
    "# The REST endpoint to call is at `/predict`\n",
    "endpoint =  f'{deployment.url}/predict'\n",
    "\n",
    "# send the POST request and get the response\n",
    "response = requests.post(endpoint, data=input_data, auth=auth)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can look at the returned object in json, loading it into a pandas Dataframe for better readability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "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>acct_num</th>\n",
       "      <th>amt</th>\n",
       "      <th>category</th>\n",
       "      <th>cc_num</th>\n",
       "      <th>city</th>\n",
       "      <th>city_pop</th>\n",
       "      <th>dob</th>\n",
       "      <th>first</th>\n",
       "      <th>gender</th>\n",
       "      <th>is_fraud</th>\n",
       "      <th>...</th>\n",
       "      <th>profile</th>\n",
       "      <th>ssn</th>\n",
       "      <th>state</th>\n",
       "      <th>street</th>\n",
       "      <th>trans_date</th>\n",
       "      <th>trans_num</th>\n",
       "      <th>trans_time</th>\n",
       "      <th>unix_time</th>\n",
       "      <th>zip</th>\n",
       "      <th>prediction</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>60.51</td>\n",
       "      <td>grocery_pos</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-23</td>\n",
       "      <td>fe1a26b8d4d6d904c823eddbde649479</td>\n",
       "      <td>08:03:39</td>\n",
       "      <td>1335168219</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>71.11</td>\n",
       "      <td>shopping_net</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-09-16</td>\n",
       "      <td>0b9e6299059906f5f9e0daa7df76dd62</td>\n",
       "      <td>05:30:19</td>\n",
       "      <td>1347773419</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>68.48</td>\n",
       "      <td>food_dining</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2013-03-19</td>\n",
       "      <td>504e5b7897a36d5ae3fda83565ffe2bc</td>\n",
       "      <td>00:34:03</td>\n",
       "      <td>1363653243</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>74.14</td>\n",
       "      <td>grocery_net</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-13</td>\n",
       "      <td>5e4569a5dae1c7aa11d04c7a7195321f</td>\n",
       "      <td>10:03:13</td>\n",
       "      <td>1334311393</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>662887798281</td>\n",
       "      <td>52.62</td>\n",
       "      <td>grocery_pos</td>\n",
       "      <td>343926142939687</td>\n",
       "      <td>Harrisburg</td>\n",
       "      <td>165527</td>\n",
       "      <td>1943-03-05</td>\n",
       "      <td>Gary</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>adults_50up_male_urban.json</td>\n",
       "      <td>674-05-2939</td>\n",
       "      <td>PA</td>\n",
       "      <td>185 Connor Fort</td>\n",
       "      <td>2012-04-28</td>\n",
       "      <td>973e3642c75c14cd199a83108bd9fe09</td>\n",
       "      <td>11:05:46</td>\n",
       "      <td>1335611146</td>\n",
       "      <td>17110</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       acct_num    amt      category           cc_num        city  city_pop  \\\n",
       "0  662887798281  60.51   grocery_pos  343926142939687  Harrisburg    165527   \n",
       "1  662887798281  71.11  shopping_net  343926142939687  Harrisburg    165527   \n",
       "2  662887798281  68.48   food_dining  343926142939687  Harrisburg    165527   \n",
       "3  662887798281  74.14   grocery_net  343926142939687  Harrisburg    165527   \n",
       "4  662887798281  52.62   grocery_pos  343926142939687  Harrisburg    165527   \n",
       "\n",
       "          dob first  gender  is_fraud  ...                      profile  \\\n",
       "0  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "1  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "2  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "3  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "4  1943-03-05  Gary       1         0  ...  adults_50up_male_urban.json   \n",
       "\n",
       "           ssn  state           street  trans_date  \\\n",
       "0  674-05-2939     PA  185 Connor Fort  2012-04-23   \n",
       "1  674-05-2939     PA  185 Connor Fort  2012-09-16   \n",
       "2  674-05-2939     PA  185 Connor Fort  2013-03-19   \n",
       "3  674-05-2939     PA  185 Connor Fort  2012-04-13   \n",
       "4  674-05-2939     PA  185 Connor Fort  2012-04-28   \n",
       "\n",
       "                          trans_num trans_time   unix_time    zip prediction  \n",
       "0  fe1a26b8d4d6d904c823eddbde649479   08:03:39  1335168219  17110        0.0  \n",
       "1  0b9e6299059906f5f9e0daa7df76dd62   05:30:19  1347773419  17110        0.0  \n",
       "2  504e5b7897a36d5ae3fda83565ffe2bc   00:34:03  1363653243  17110        0.0  \n",
       "3  5e4569a5dae1c7aa11d04c7a7195321f   10:03:13  1334311393  17110        0.0  \n",
       "4  973e3642c75c14cd199a83108bd9fe09   11:05:46  1335611146  17110        0.0  \n",
       "\n",
       "[5 rows x 27 columns]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = response.json()\n",
    "pd.DataFrame(results['predictions']).head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are done: you explored the data, created a model, trained it on a large dataset, then created a batch inference application you can call on demand, and a real-time inference server you can call with the REST endpoint."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Clean up\n",
    "\n",
    "### 11.1 Undeploy and delete the model deployment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# deployment.config=ads.common.auth.resource_principal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deployment.delete(wait_for_completion=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.2 Delete the model from Model Catalog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelCatalog(compartment_id=os.environ['NB_SESSION_COMPARTMENT_OCID']).delete_model(model_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3 Delete the DataFlow applications\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look up the app ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ads.set_auth(auth='resource_principal')\n",
    "data_flow = DataFlow(dataflow_base_folder=dataflow_basefolder)\n",
    "pd.DataFrame(json.loads(str(data_flow.list_apps())))[['display_name', 'id']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Replace the '<app_id>' in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ads.set_auth(auth='resource_principal')\n",
    "data_flow_client = oci.data_flow.DataFlowClient(config={}, signer=ads.common.auth.resource_principal()['signer'])\n",
    "data_flow_client.delete_application(application_id='<app_id>')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4 Delete local files\n",
    "\n",
    "Delete the local model deployment files, including the score.py and Spark model downloaded from Object Storage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf ./fraud-detection-model-deployment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete the local Data Flow application files, and output files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf ./dataflow\n",
    "!rm -rf ./output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5 Delete the datasets and dataset generator \n",
    "\n",
    "The next cell will delete the git repository cloned at the beginning, including all the data generated using the tool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf ~/Sparkov_Data_Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"reference\"></a>\n",
    "# References\n",
    "\n",
    "- [ADS Library Documentation](https://docs.cloud.oracle.com/en-us/iaas/tools/ads-sdk/latest/index.html)\n",
    "- [Data Science YouTube Videos](https://www.youtube.com/playlist?list=PLKCk3OyNwIzv6CWMhvqSB_8MLJIZdO80L)\n",
    "- [OCI Data Science Documentation](https://docs.cloud.oracle.com/en-us/iaas/data-science/using/data-science.htm)\n",
    "- [Oracle Data & AI Blog](https://blogs.oracle.com/datascience/)\n",
    "- [Understanding Conda Environments](https://docs.cloud.oracle.com/en-us/iaas/data-science/using/use-notebook-sessions.htm#conda_understand_environments)\n",
    "- [Use Resource Manager to Configure Your Tenancy for Data Science](https://docs.cloud.oracle.com/en-us/iaas/data-science/using/orm-configure-tenancy.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.1 (default, Apr 11 2022, 16:41:58) \n[Clang 12.0.0 (clang-1200.0.31.1)]"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  },
  "vscode": {
   "interpreter": {
    "hash": "d2af76a8328cd5db770fd4a1362370f863c2a9510e27c11bf7934b7aa2dbd192"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}