fraud_detection_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d3002ab4",
   "metadata": {},
   "source": [
    "# Insurance Fraud Detection Demo\n",
    "\n",
    "The goal of this demo is to showcase how Memgraph can be used to load table data from different sources like parquet files stored in local or external file systems. This is a step-by-step showcase of Memgraph ecosystem. The demo is split into different topics:\n",
    "\n",
    "##### 1.  Storing row-based format into Memgraph\n",
    "Such row-based formats are SQL tables, Parquet data frames, as well as CSV, ORC and Feather files. Therefore, these row-based records can be transformed into graph via suitable transformations to nodes and relationships. To accomplish that, GQLAlchemy offers a solution in a form of defining a configuration for loading each table.\n",
    "\n",
    "##### 2.  Exploring the dataset by using GQLAchemy querying\n",
    "With simple queries, information can be gathered by using GQLAlchemy. Fetching these elements enables user to get more insight into different parts of dataset and to create queries which offer a human way of interacting with frauds. For example, gathering all fraud individuals that share an address will lead towards new suspects.\n",
    "\n",
    "##### 3.  Extracting graph features from the dataset\n",
    "Graph algorithms are suitable for use cases such as fraud detection because of the amplification of relationships within the dataset entities. Community detection, PageRank and Node2Vec are just a few of those that we will use to showcase abilities of Memgraph MAGE to extract useful information from graph data. \n",
    "\n",
    "##### 4.  Preparing and running the prediction model based on extracted features\n",
    "Furthermore in the pipeline, once we have extracted features, we can simply run a prediction model on top of them. This enables to adapt to changes and once new data is created, use the model to predict on history information.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8efba43e",
   "metadata": {},
   "source": [
    "## Prerequisites\n",
    "\n",
    "For this tutorial, you will need to install:\n",
    "\n",
    "- [Jupyter](https://jupyter.org/install): Jupyter is needed if you want to run this tutorial as a notebook.\n",
    "- [Docker](https://docs.docker.com/get-docker/): Docker is used because Memgraph is a native Linux application and cannot be installed on Windows and macOS.\n",
    "- [GQLAlchemy](https://pypi.org/project/gqlalchemy/): A Python OGM (Object Graph Mapper) that connects to Memgraph\n",
    "- other Python packages from `pyproject.toml`. You can install them with `poetry install`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46356096",
   "metadata": {},
   "source": [
    "#### Installation using Docker\n",
    "\n",
    "After you install Docker, you can set up Memgraph by running:\n",
    "\n",
    "```\n",
    "docker run -it -p 7687:7687 -p 3000:3000 memgraph/memgraph-platform\n",
    "```\n",
    "\n",
    "This command will start the download and after it finishes, run the Memgraph container."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "932f236e",
   "metadata": {},
   "source": [
    "#### Connect to Memgraph with GQLAlchemy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "928dc543",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the library needed for graph data handling\n",
    "# GQLAlchemy is the Object Graph Mapper (OGM) - a link between graph database objects and Python objects.\n",
    "import gqlalchemy\n",
    "\n",
    "# Import key features from GQLAlchemy\n",
    "from gqlalchemy import Memgraph, QueryBuilder\n",
    "from gqlalchemy.loaders import ParquetLocalFileSystemImporter\n",
    "\n",
    "# Import environment config and file handlers\n",
    "from dotenv import load_dotenv\n",
    "from pathlib import Path\n",
    "import os\n",
    "import yaml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1683742c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load configuration from environment file\n",
    "load_dotenv(\".env\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a19c382f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a graph DB connector\n",
    "mg_host = os.getenv(\"MG_HOST\", \"localhost\")\n",
    "mg_port = int(os.getenv(\"MG_PORT\", \"7687\"))\n",
    "db = Memgraph(mg_host, mg_port)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faadc145",
   "metadata": {},
   "source": [
    " ### 1. Storing row-based format into Memgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c113044",
   "metadata": {},
   "source": [
    "To use the mock dataset run the `data_generator` script. Parameters are `<TOTAL_FAMILIES>` and `<TOTAL_INCIDENTS>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "27ad15dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data generation started...\n",
      "Data stored in dataset/data !\n"
     ]
    }
   ],
   "source": [
    "!python dataset/data_generator.py 1000 300"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf14faf",
   "metadata": {},
   "source": [
    "Now, define a mapping between Tables and Nodes/Relationships - nodes are graph entities that are\n",
    "connected with relationships. We can define them on table-like format and insert them from any\n",
    "row-based storage such are SQL table, parquet dataframes, CSV files, etc. The only thing neded is \n",
    "defining mapping between these entities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f5cc7c97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created index for ADDRESS on add_id\n",
      "Created index for INDIVIDUAL on ind_id\n",
      "Created index for VEHICLE on veh_id\n",
      "Created index for POLICY on pol_id\n",
      "Created index for CLAIM on clm_id\n",
      "Created index for INCIDENT on inc_id\n",
      "Created index for CLAIM_PAYMENT on pay_id\n",
      "Created index for INJURY on inj_id\n",
      "Created trigger INDIVIDUAL__add_id__ADDRESS__add_id\n",
      "Created trigger ADDRESS__add_id__INDIVIDUAL__add_id\n",
      "Created trigger POLICY__insurer_id__INDIVIDUAL__ind_id\n",
      "Created trigger INDIVIDUAL__ind_id__POLICY__insurer_id\n",
      "Created trigger POLICY__insured_with_id__INDIVIDUAL__ind_id\n",
      "Created trigger INDIVIDUAL__ind_id__POLICY__insured_with_id\n",
      "Created trigger POLICY__veh_id__VEHICLE__veh_id\n",
      "Created trigger VEHICLE__veh_id__POLICY__veh_id\n",
      "Created trigger POLICY__add_id__ADDRESS__add_id\n",
      "Created trigger ADDRESS__add_id__POLICY__add_id\n",
      "Created trigger CLAIM__inc_id__INCIDENT__inc_id\n",
      "Created trigger INCIDENT__inc_id__CLAIM__inc_id\n",
      "Created trigger INCIDENT__pol_id__POLICY__pol_id\n",
      "Created trigger POLICY__pol_id__INCIDENT__pol_id\n",
      "Created trigger INCIDENT__add_id__ADDRESS__add_id\n",
      "Created trigger ADDRESS__add_id__INCIDENT__add_id\n",
      "Created trigger CLAIM_PAYMENT__payer_id__INDIVIDUAL__ind_id\n",
      "Created trigger INDIVIDUAL__ind_id__CLAIM_PAYMENT__payer_id\n",
      "Created trigger CLAIM_PAYMENT__payee_id__INDIVIDUAL__ind_id\n",
      "Created trigger INDIVIDUAL__ind_id__CLAIM_PAYMENT__payee_id\n",
      "Created trigger CLAIM_PAYMENT__clm_id__CLAIM__clm_id\n",
      "Created trigger CLAIM__clm_id__CLAIM_PAYMENT__clm_id\n",
      "Created trigger INJURY__clm_id__CLAIM__clm_id\n",
      "Created trigger CLAIM__clm_id__INJURY__clm_id\n",
      "Created trigger INJURY__ind_id__INDIVIDUAL__ind_id\n",
      "Created trigger INDIVIDUAL__ind_id__INJURY__ind_id\n",
      "Loading data from table ./dataset/data//address.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//individuals.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//vehicle.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//policy.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//claim.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//incident.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//claim_payment.parquet...\n",
      "Data loaded.\n",
      "Loading data from table ./dataset/data//injury.parquet...\n",
      "Data loaded.\n",
      "Loading data from cross table ./dataset/data//incident_individual.parquet...\n",
      "Data loaded.\n"
     ]
    }
   ],
   "source": [
    "PATH_TO_CONFIG_YAML = \"./config.yml\"\n",
    "\n",
    "with Path(PATH_TO_CONFIG_YAML).open(\"r\") as f_:\n",
    "    data_configuration = yaml.safe_load(f_)\n",
    "\n",
    "translator = ParquetLocalFileSystemImporter(\n",
    "    path=\"./dataset/data/\",\n",
    "    data_configuration=data_configuration\n",
    ")\n",
    "\n",
    "# Ensure that Memgraph is in clean state once we start out loading\n",
    "translator.translate(drop_database_on_start=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cccd995",
   "metadata": {},
   "source": [
    "![](img/demo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d50c32c0",
   "metadata": {},
   "source": [
    "### 3. Exploring the dataset by using GQLAchemy querying"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e1ccfec",
   "metadata": {},
   "source": [
    "Now, when we have everything settled, we are able to explore the data from Memgraph DB.\n",
    "Querying should be fairly simple, using the GQLAlchemy or openCypher query language.\n",
    "\n",
    "Here is the example of fetching policies from some individuals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b8362613",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Katherine Richard is insured with POLICY: {valid_from: 2022-02-19, valid_to: 2022-09-09, policy_type: MEDICAL}\n",
      "John Richard is insured with POLICY: {valid_from: 2022-08-28, valid_to: 2024-06-02, policy_type: MEDICAL}\n",
      "Jorge Richard is insured with POLICY: {valid_from: 2022-06-02, valid_to: 2023-06-02, policy_type: MEDICAL}\n",
      "Jacqueline Poole is insured with POLICY: {valid_from: 2021-05-27, valid_to: 2022-11-02, policy_type: COLLISION}\n",
      "Jacqueline Poole is insured with POLICY: {valid_from: 2020-10-12, valid_to: 2021-12-04, policy_type: COMPREHENSIVE}\n"
     ]
    }
   ],
   "source": [
    "query_builder = QueryBuilder(db)\n",
    "results = list(\n",
    "    query_builder.match() # Match different entities\n",
    "    .node(\"POLICY\", variable=\"policy\") # Match policies\n",
    "    .to(\"INSURED\") # With relationship INSURED\n",
    "    .node(\"INDIVIDUAL\", variable=\"insurer\") # To an individual\n",
    "    .return_() # Return all the variables\n",
    "    .limit(5) # Limit the output to 5 elements\n",
    "    .execute()\n",
    ")\n",
    "\n",
    "# Log the output for each of the resulting rows\n",
    "for result in results:\n",
    "    insurer = result[\"insurer\"]\n",
    "    policy = result[\"policy\"]\n",
    "    \n",
    "    print(f\"{insurer.first_name} {insurer.last_name} \"\n",
    "          f\"is insured with POLICY: \"\n",
    "          f\"{{valid_from: {policy.start_date}, valid_to: {policy.end_date}, policy_type: { policy.type}}}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ba9e18f",
   "metadata": {},
   "source": [
    "Let's say we are curious about getting the individual with largest number of policies\n",
    "This time, we will write a raw openCypher query for larger flexibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c97dc5c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erica Gomez has 6 policies.\n",
      "Lindsey Martinez has 6 policies.\n",
      "Stephanie Quinn has 5 policies.\n",
      "Janet Glass has 5 policies.\n",
      "Jodi Martinez has 4 policies.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "results = db.execute_and_fetch(\"\"\"\n",
    "    MATCH (insurer:INDIVIDUAL)<-[:INSURED]-(policy:POLICY)\n",
    "    RETURN insurer, count(policy) AS num_policies\n",
    "    ORDER BY num_policies DESC\n",
    "    LIMIT 5;\n",
    "\"\"\")\n",
    "\n",
    "# Log the output for each of the resulting rows\n",
    "for result in results:\n",
    "    insurer = result[\"insurer\"]\n",
    "    num_policies = result[\"num_policies\"]\n",
    "    \n",
    "    print(f\"{insurer.first_name} {insurer.last_name} has {num_policies} policies.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36db0efc",
   "metadata": {},
   "source": [
    "Moving into the interest area of potential frauds,\n",
    "here we list some fraudulent claims and their associates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7fa50e40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Christopher Flores was involved in claim 982a6d40 which was marked as fraud.\n",
      "Jesse Hodges was involved in claim f0a097e6 which was marked as fraud.\n",
      "Christina Hart was involved in claim c01da58d which was marked as fraud.\n",
      "Taylor Flores was involved in claim ac0e5ed5 which was marked as fraud.\n",
      "Mary Nguyen was involved in claim 3818a6da which was marked as fraud.\n"
     ]
    }
   ],
   "source": [
    "results = db.execute_and_fetch(\"\"\"\n",
    "    MATCH (individual:INDIVIDUAL)<-[:INSURED]-(policy:POLICY)<-[]-(incident:INCIDENT)<-[]-(fraud:CLAIM {fraud: True})\n",
    "    RETURN individual, fraud\n",
    "    LIMIT 5;\n",
    "\"\"\")\n",
    "\n",
    "# Log the output for each of the resulting rows\n",
    "for result in results:\n",
    "    insurer = result[\"individual\"]\n",
    "    fraudulent_claim = result[\"fraud\"]\n",
    "    \n",
    "    print(f\"{insurer.first_name} {insurer.last_name} was involved in claim {fraudulent_claim.clm_id} which was marked as fraud.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b804df2",
   "metadata": {},
   "source": [
    "After obtaining frauds in history, we would like to extract features for each of them, and encorporate\n",
    "them to detect the new fraud. \n",
    "\n",
    "First, we need to simulate out feature store. For these purposes, we'll use Pandas, frequent DataFrame format\n",
    "Let's define some features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "05d68a25",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "class FeatureStore:\n",
    "    IND_COUNT = \"ind_count\"\n",
    "    AMT_PAID = \"amount_paid\"\n",
    "    POL_EXPIRED = \"policy_expired\"\n",
    "    POL_PREMIUM = \"policy_premium\"\n",
    "    INFLUENCE = \"influence\"\n",
    "    NUM_FRAUDS_NEIGHBORHOOD = \"num_frauds_neighborhood\"\n",
    "    NUM_FRAUDS_COMMUNITY = \"num_frauds_community\"\n",
    "    EMBEDDING = \"embedding\"\n",
    "    FRAUD = 'fraud'\n",
    "    \n",
    "    \n",
    "FEATURE_NAMES = [\n",
    "    FeatureStore.IND_COUNT, \n",
    "    FeatureStore.AMT_PAID, \n",
    "    FeatureStore.POL_EXPIRED, \n",
    "    FeatureStore.POL_PREMIUM, \n",
    "    FeatureStore.INFLUENCE, \n",
    "    FeatureStore.NUM_FRAUDS_NEIGHBORHOOD, \n",
    "    FeatureStore.NUM_FRAUDS_COMMUNITY, \n",
    "    FeatureStore.EMBEDDING, \n",
    "    FeatureStore.FRAUD, \n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2361b73",
   "metadata": {},
   "source": [
    "First, define simple feature types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "aaf53c1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, date\n",
    "\n",
    "# Count of individuals related to the incident/claim could be\n",
    "# useful information when combined with other features.\n",
    "def get_individual_count(claim_id: str) -> int:\n",
    "    return next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})-[]->(incident:INCIDENT)-[]->(individual:INDIVIDUAL)\n",
    "        RETURN COUNT(individual) AS {FeatureStore.IND_COUNT}\n",
    "    \"\"\"))[FeatureStore.IND_COUNT]\n",
    "\n",
    "\n",
    "# Price paid for the claim can be a fine indicator of whether there\n",
    "# is a suspicious activity going on.\n",
    "def get_amount_paid(claim_id: str) -> float:\n",
    "    amt_paid =  next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})<-[]-(payment:CLAIM_PAYMENT)\n",
    "        RETURN SUM(payment.amount) AS {FeatureStore.AMT_PAID}\n",
    "    \"\"\"))[FeatureStore.AMT_PAID]\n",
    "    \n",
    "    return amt_paid if amt_paid else 0\n",
    "\n",
    "\n",
    "# Filing a claim on expired policy might be a bad sign\n",
    "def get_policy_expired(claim_id: str) -> bool:\n",
    "    today = str(datetime.now().date())\n",
    "    return next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})-[]->(:INCIDENT)-[]->(policy:POLICY)\n",
    "        RETURN  policy.end_date < date('{today}') AS {FeatureStore.POL_EXPIRED}\n",
    "    \"\"\"))[FeatureStore.POL_EXPIRED]\n",
    "\n",
    "\n",
    "# Depending on premium level, the amount covered can vary, suspicion too.\n",
    "def get_policy_premium(claim_id: str) -> bool:\n",
    "    premium = next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})-[]->(:INCIDENT)-[]->(policy:POLICY)\n",
    "        RETURN  policy.premium AS {FeatureStore.POL_PREMIUM} \n",
    "    \"\"\"))[FeatureStore.POL_PREMIUM]\n",
    "    return premium if premium else \"U\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4fcabbb",
   "metadata": {},
   "source": [
    "Choose one claim id and set it as a variable to be used in these examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c29bf50e",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_claim_id = \"982a6d40\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "19fec625",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of individuals involved:  3\n",
      "Total amount paid:  7175.7\n",
      "Is policy expired:  False\n",
      "Policy premium type:  U\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of individuals involved: \", get_individual_count(test_claim_id))\n",
    "print(\"Total amount paid: \", get_amount_paid(test_claim_id))\n",
    "print(\"Is policy expired: \", get_policy_expired(test_claim_id))\n",
    "print(\"Policy premium type: \", get_policy_premium(test_claim_id))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "867f46af",
   "metadata": {},
   "source": [
    "### 4.  Extracting graph features from the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22886506",
   "metadata": {},
   "source": [
    "It's time to apply some graph analytics on our fraud model\n",
    "\n",
    "After splitting the graph entities into communities, communities with individuals\n",
    "related to previous frauds will have larger probability of being fraudulent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9fa28581",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_community_detection() -> None:\n",
    "    db.execute(f\"\"\"\n",
    "        CALL community_detection_online.set() YIELD node, community_id\n",
    "        SET node.community = community_id;\n",
    "    \"\"\")\n",
    "\n",
    "# Measure of centrality can help \n",
    "def run_pagerank() -> None:\n",
    "    db.execute(f\"\"\"\n",
    "        CALL pagerank_online.set(100, 0.2) YIELD node, rank\n",
    "        SET node.influence = rank;\n",
    "    \"\"\")\n",
    "\n",
    "\n",
    "# These are highly artificial vectors of numbers, but they encode a graph structure.\n",
    "# Malicious groups act alike, therefore their structural encodings will be the same.\n",
    "def run_node_embedding() -> None:\n",
    "    db.execute(f\"\"\"\n",
    "        CALL node2vec.set_embeddings() YIELD *;\n",
    "    \"\"\")\n",
    "\n",
    "run_community_detection()\n",
    "run_pagerank()\n",
    "run_node_embedding()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0e28e97d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of frauds in community:  1\n",
      "Number of close/related frauds:  0\n",
      "Claim influence:  0.00010544430735411197\n",
      "\n",
      "Claim vector embedding [0.09475097805261612, 0.2893894910812378, 0.10628315061330795, -0.18005914986133575, 0.08311939984560013, -0.1795181781053543, -0.0664520263671875, 0.01584327034652233, 0.11893633753061295, -0.15397332608699799, -0.1455812156200409, -0.2777945101261139, 0.06764007359743118, 0.14838582277297974, -0.019456954672932625, -0.08026906847953796, -0.18999165296554565, -0.28295910358428955, 0.06002788990736008, 0.0555458627641201, 0.1072806864976883, -0.05415064096450806, 0.02410547249019146, -0.021786928176879883, 0.15650144219398499, -0.24369214475154877, 0.11819690465927124, 0.03465935215353966, -0.05355159565806389, -0.20859570801258087, -0.016595518216490746, 0.04156307503581047, -0.16977497935295105, -0.14370673894882202, 0.1429239958524704, -0.14620448648929596, 0.08028645813465118, -0.15954887866973877, 0.059030674397945404, -0.10856687277555466, 0.12861576676368713, -0.07062320411205292, -0.042569223791360855, -0.14762018620967865, 0.04332071542739868, 0.015514468774199486, -0.13306857645511627, 0.13148917257785797, -0.00990111380815506, 0.18803773820400238, 0.030887635424733162, 0.013794488273561, -0.1310429573059082, -0.07743377983570099, -0.11023274064064026, 0.09743542224168777, -0.0032801502384245396, 0.05630887672305107, -0.05426527187228203, -0.020545244216918945, 0.01524496078491211, 0.0038668205961585045, -0.40450266003608704, 0.25178924202919006, 0.12475520372390747, -0.10376880317926407, -0.18228060007095337, -0.025108840316534042, 0.18765535950660706, 0.15029391646385193, -0.13819274306297302, -0.006275067571550608, 0.05862043797969818, -0.3362993001937866, -0.057939719408750534, 0.06536509096622467, 0.07128150761127472, -0.064283587038517, -0.16780270636081696, 0.14109104871749878, 0.03958350419998169, -0.14743131399154663, 0.044143736362457275, 0.16643811762332916, -0.08607257902622223, -0.04797830432653427, -0.05593050643801689, 0.09562623500823975, 0.1818484216928482, 0.1889013797044754, -0.13319557905197144, -0.07528715580701828, 0.057363782078027725, -0.05470523610711098, 0.06274407356977463, 0.012133678421378136, 0.07289443910121918, -0.26263129711151123, -0.10135319828987122, 0.22856687009334564]\n"
     ]
    }
   ],
   "source": [
    "def get_num_frauds_community(claim_id: str) -> float:\n",
    "    return next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}}), (fraud:CLAIM {{fraud: True}})\n",
    "        WHERE claim.community = fraud.community\n",
    "        RETURN COUNT(fraud) AS {FeatureStore.NUM_FRAUDS_COMMUNITY}\n",
    "    \"\"\"))[FeatureStore.NUM_FRAUDS_COMMUNITY]\n",
    "\n",
    "def get_num_frauds_neighborhood(claim_id: str) -> float:\n",
    "    return next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})-[*bfs ..4]-(fraud:CLAIM {{fraud: True}})\n",
    "        RETURN COUNT(fraud) AS {FeatureStore.NUM_FRAUDS_NEIGHBORHOOD}\n",
    "    \"\"\"))[FeatureStore.NUM_FRAUDS_NEIGHBORHOOD]\n",
    "\n",
    "def get_influence(claim_id: str) -> float:\n",
    "    return next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})\n",
    "        RETURN claim.influence AS {FeatureStore.INFLUENCE}\n",
    "    \"\"\"))[FeatureStore.INFLUENCE]\n",
    "\n",
    "def get_embedding(claim_id: str) -> float:\n",
    "    return next(db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM {{clm_id: '{claim_id}'}})\n",
    "        RETURN claim.embedding AS {FeatureStore.EMBEDDING}\n",
    "    \"\"\"))[FeatureStore.EMBEDDING]\n",
    "\n",
    "print(\"Number of frauds in community: \", get_num_frauds_community(test_claim_id))\n",
    "print(\"Number of close/related frauds: \", get_num_frauds_neighborhood(test_claim_id))\n",
    "print(\"Claim influence: \", get_influence(test_claim_id))\n",
    "print()\n",
    "print(\"Claim vector embedding\", get_embedding(test_claim_id))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bd52a22",
   "metadata": {},
   "source": [
    "Generate all features for each possible claim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ffeab41a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/mg/Workspace/code/memgraph/insurance-fraud/ve3/lib/python3.10/site-packages/gqlalchemy/models.py:321: GQLAlchemySubclassNotFoundWarning: ({'CLAIM'}, <class 'gqlalchemy.models.Node'>)\n",
      "  warnings.warn(GQLAlchemySubclassNotFoundWarning(types, cls))\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [43], line 19\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, result \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(get_claims()):\n\u001b[1;32m     15\u001b[0m     claim \u001b[38;5;241m=\u001b[39m result[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mclaim\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m     16\u001b[0m     claim_features \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m     17\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mIND_COUNT: get_individual_count(claim\u001b[38;5;241m.\u001b[39mclm_id),\n\u001b[1;32m     18\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mAMT_PAID: get_amount_paid(claim\u001b[38;5;241m.\u001b[39mclm_id),\n\u001b[0;32m---> 19\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mPOL_EXPIRED: \u001b[43mget_policy_expired\u001b[49m\u001b[43m(\u001b[49m\u001b[43mclaim\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclm_id\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m     20\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mPOL_PREMIUM: get_policy_premium(claim\u001b[38;5;241m.\u001b[39mclm_id),\n\u001b[1;32m     21\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mNUM_FRAUDS_COMMUNITY: get_num_frauds_community(claim\u001b[38;5;241m.\u001b[39mclm_id),\n\u001b[1;32m     22\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mNUM_FRAUDS_NEIGHBORHOOD: get_num_frauds_neighborhood(claim\u001b[38;5;241m.\u001b[39mclm_id),\n\u001b[1;32m     23\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mINFLUENCE: get_influence(claim\u001b[38;5;241m.\u001b[39mclm_id),\n\u001b[1;32m     24\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mEMBEDDING: [get_embedding(claim\u001b[38;5;241m.\u001b[39mclm_id)],\n\u001b[1;32m     25\u001b[0m         FeatureStore\u001b[38;5;241m.\u001b[39mFRAUD: claim\u001b[38;5;241m.\u001b[39mfraud,\n\u001b[1;32m     26\u001b[0m         CLAIM_ID: claim\u001b[38;5;241m.\u001b[39mclm_id\n\u001b[1;32m     27\u001b[0m     }\n\u001b[1;32m     28\u001b[0m     feature_store \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mconcat([feature_store, pd\u001b[38;5;241m.\u001b[39mDataFrame(claim_features)], ignore_index\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m     30\u001b[0m feature_store \u001b[38;5;241m=\u001b[39m feature_store\u001b[38;5;241m.\u001b[39mset_index(CLAIM_ID)\n",
      "Cell \u001b[0;32mIn [12], line 26\u001b[0m, in \u001b[0;36mget_policy_expired\u001b[0;34m(claim_id)\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_policy_expired\u001b[39m(claim_id: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mbool\u001b[39m:\n\u001b[1;32m     25\u001b[0m     today \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(datetime\u001b[38;5;241m.\u001b[39mnow()\u001b[38;5;241m.\u001b[39mdate())\n\u001b[0;32m---> 26\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdb\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute_and_fetch\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\n\u001b[1;32m     27\u001b[0m \u001b[38;5;124;43m        MATCH (claim:CLAIM \u001b[39;49m\u001b[38;5;130;43;01m{{\u001b[39;49;00m\u001b[38;5;124;43mclm_id: \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mclaim_id\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;130;43;01m}}\u001b[39;49;00m\u001b[38;5;124;43m)-[]->(:INCIDENT)-[]->(policy:POLICY)\u001b[39;49m\n\u001b[1;32m     28\u001b[0m \u001b[38;5;124;43m        RETURN  policy.end_date < date(\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mtoday\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m) AS \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mFeatureStore\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mPOL_EXPIRED\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\n\u001b[1;32m     29\u001b[0m \u001b[38;5;124;43m    \u001b[39;49m\u001b[38;5;124;43m\"\"\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m[FeatureStore\u001b[38;5;241m.\u001b[39mPOL_EXPIRED]\n",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def get_claims():\n",
    "    return db.execute_and_fetch(f\"\"\"\n",
    "        MATCH (claim:CLAIM)\n",
    "        RETURN claim\n",
    "    \"\"\")\n",
    "\n",
    "CLAIM_ID = 'claim_id'\n",
    "feature_store = pd.DataFrame(columns = FEATURE_NAMES + [CLAIM_ID])\n",
    "\n",
    "\n",
    "# Store the claims into feature store - a dataframe\n",
    "for i, result in enumerate(get_claims()):\n",
    "    claim = result['claim']\n",
    "    claim_features = {\n",
    "        FeatureStore.IND_COUNT: get_individual_count(claim.clm_id),\n",
    "        FeatureStore.AMT_PAID: get_amount_paid(claim.clm_id),\n",
    "        FeatureStore.POL_EXPIRED: get_policy_expired(claim.clm_id),\n",
    "        FeatureStore.POL_PREMIUM: get_policy_premium(claim.clm_id),\n",
    "        FeatureStore.NUM_FRAUDS_COMMUNITY: get_num_frauds_community(claim.clm_id),\n",
    "        FeatureStore.NUM_FRAUDS_NEIGHBORHOOD: get_num_frauds_neighborhood(claim.clm_id),\n",
    "        FeatureStore.INFLUENCE: get_influence(claim.clm_id),\n",
    "        FeatureStore.EMBEDDING: [get_embedding(claim.clm_id)],\n",
    "        FeatureStore.FRAUD: claim.fraud,\n",
    "        CLAIM_ID: claim.clm_id\n",
    "    }\n",
    "    feature_store = pd.concat([feature_store, pd.DataFrame(claim_features)], ignore_index=True)\n",
    "\n",
    "feature_store = feature_store.set_index(CLAIM_ID)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ef3619e",
   "metadata": {},
   "source": [
    "### 5.  Preparing and running the prediction model based on extracted features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "21d9fb60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='Predicted', ylabel='Actual'>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.utils import resample\n",
    "from sklearn import metrics\n",
    "import seaborn as sn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# Extracting the features for training phase out of feature store\n",
    "X = feature_store[[\n",
    "    FeatureStore.IND_COUNT, \n",
    "    FeatureStore.AMT_PAID, \n",
    "    FeatureStore.NUM_FRAUDS_COMMUNITY,\n",
    "    FeatureStore.POL_PREMIUM,\n",
    "    FeatureStore.NUM_FRAUDS_NEIGHBORHOOD,\n",
    "    FeatureStore.INFLUENCE,\n",
    "]]\n",
    "# Selecting the feature type. \n",
    "X = X.astype({\n",
    "    FeatureStore.IND_COUNT: int,\n",
    "    FeatureStore.AMT_PAID: float,\n",
    "    FeatureStore.NUM_FRAUDS_COMMUNITY: int,\n",
    "    FeatureStore.POL_PREMIUM: \"category\",\n",
    "    FeatureStore.NUM_FRAUDS_NEIGHBORHOOD: int,\n",
    "    FeatureStore.INFLUENCE: float,\n",
    "})\n",
    "\n",
    "# If feature is categorical, encode them in one-hot encoding scheme\n",
    "dummies = pd.get_dummies(X[FeatureStore.POL_PREMIUM], prefix=FeatureStore.POL_PREMIUM)\n",
    "X = X.join(dummies)\n",
    "X = X.drop(columns=[FeatureStore.POL_PREMIUM])\n",
    "y = feature_store[FeatureStore.FRAUD]\n",
    "y = y.astype({\n",
    "    FeatureStore.FRAUD: bool,\n",
    "})\n",
    "feature_columns = X.columns\n",
    "\n",
    "# Split the dataset into training and testing\n",
    "# NOTE: In real-life scenario, this split will be time-dependent\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=0)\n",
    "\n",
    "# Upsample the minority class data\n",
    "train_data = pd.concat((X_train, y_train), axis=1)\n",
    "X_positive = train_data[train_data[FeatureStore.FRAUD] == True]\n",
    "X_negative = train_data[train_data[FeatureStore.FRAUD] == False]\n",
    "\n",
    "X_positive = resample(X_positive, \n",
    "                      replace=True,    \n",
    "                      n_samples=len(X_negative) // 2)\n",
    "train_data = pd.concat((X_positive, X_negative), axis=0)\n",
    "\n",
    "y_train = train_data[FeatureStore.FRAUD]\n",
    "X_train = train_data.drop(columns=[FeatureStore.FRAUD])\n",
    "\n",
    "# Fit the simplest logistic regression model by using scikit-learn \n",
    "logistic_regression= LogisticRegression()\n",
    "logistic_regression.fit(X_train,y_train)\n",
    "y_pred=logistic_regression.predict(X_test)\n",
    "\n",
    "# Draw a confusion matrix and discuss the results. Here, the results are\n",
    "# correlated to the dataset which is not highly accurate.\n",
    "confusion_matrix = pd.crosstab(y_test, y_pred, rownames=['Actual'], colnames=['Predicted'])\n",
    "sn.heatmap(\n",
    "    confusion_matrix, \n",
    "    annot=True,\n",
    "    fmt='g',\n",
    "    cmap='Blues'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "2e8b9108",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To enable faster processing, Memgraph offers a dynamic analytics. Once data is inserted, analytics\n",
    "# is calculated on the fly. To set it, we create triggers.\n",
    "\n",
    "def create_community_detection_trigger():\n",
    "    db.execute(\"\"\"\n",
    "        CREATE TRIGGER community_detection_online_trigger BEFORE COMMIT\n",
    "        EXECUTE CALL community_detection_online.update(createdVertices, createdEdges, updatedVertices, updatedEdges, deletedVertices, deletedEdges) YIELD node, community_id\n",
    "        SET node.community = community_id;\n",
    "    \"\"\")\n",
    "\n",
    "def create_influence_trigger():\n",
    "    db.execute(\"\"\"\n",
    "        CREATE TRIGGER influence_trigger BEFORE COMMIT\n",
    "        EXECUTE CALL pagerank_online.update(createdVertices, createdEdges, deletedVertices, deletedEdges) YIELD *\n",
    "        SET node.influence = rank;\n",
    "    \"\"\")\n",
    "    \n",
    "create_community_detection_trigger()\n",
    "create_influence_trigger()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "93420c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now let's create another item in the database\n",
    "# We'll simulate how items are inserted into SQL DB\n",
    "\n",
    "NEW_CLAIM_ID = 'bc7462cb'\n",
    "\n",
    "INCIDENT_ID = 'bf418431'\n",
    "ADDRESS_ID = '4700feb8'\n",
    "POLICY_ID = 'b74bf655'\n",
    "CLAIM2_ID = 'e93ffa1a'\n",
    "INJURY_ID = 'abde1883'\n",
    "INDIVIDUAL_ID = '7324cb18'\n",
    "PAYMENT_ID = 'bd384ce3'\n",
    "PAYEE_ID = '35d27b82'\n",
    "\n",
    "# Create INCIDENT in table\n",
    "def create_incident(incident_id, policy_id, address_id):\n",
    "    date = str(datetime.now())\n",
    "    db.execute(f\"\"\"\n",
    "    CREATE (:INCIDENT {{\n",
    "        accident_date: \"{date}\",\n",
    "        add_id: \"{address_id}\",\n",
    "        file_date: \"{date}\",\n",
    "        inc_id: \"{incident_id}\",\n",
    "        pol_id: \"{policy_id}\" \n",
    "    }});\n",
    "    \"\"\")\n",
    "\n",
    "def create_incident_individual(incident_id, individual_id):\n",
    "    db.execute(f\"\"\"\n",
    "    MATCH (a:INCIDENT {{inc_id: \"{incident_id}\"}}) \n",
    "    MATCH (b:INDIVIDUAL {{ind_id: \"{individual_id}\"}})\n",
    "    CREATE (a)-[:INCIDENT]->(b);\n",
    "    \"\"\")\n",
    "\n",
    "# Create claims\n",
    "def create_claim(claim_id, incident_id, amount):\n",
    "    db.execute(f\"\"\"\n",
    "    CREATE (:CLAIM {{\n",
    "            clm_id: \"{claim_id}\",\n",
    "            inc_id: \"{incident_id}\",\n",
    "            amount: \"{amount}\"\n",
    "    }});\n",
    "    \"\"\")\n",
    "\n",
    "# Create injuries\n",
    "def create_injury(injury_id, injury_type, claim_id, individual_id):\n",
    "    db.execute(f\"\"\"\n",
    "    CREATE (:INJURY {{\n",
    "            clm_id: \"{claim_id}\",\n",
    "            ind_id: \"\",\n",
    "            inj_id: \"{injury_id}\",\n",
    "            type: \"{injury_type}\"\n",
    "    }});\n",
    "    \"\"\")\n",
    "\n",
    "# Create payment\n",
    "def create_payment(payment_id, amount, claim_id, payer_id, payee_id):\n",
    "    db.execute(f\"\"\"\n",
    "    CREATE (:CLAIM_PAYMENT {{\n",
    "        amount: {amount},\n",
    "        clm_id: \"{claim_id}\",\n",
    "        pay_id: \"{payment_id}\",\n",
    "        payee_id: \"{payee_id}\",\n",
    "        payer_id: \"{payer_id}\"\n",
    "    }});\n",
    "    \"\"\")\n",
    "\n",
    "create_incident(INCIDENT_ID, POLICY_ID, ADDRESS_ID)\n",
    "create_incident_individual(INCIDENT_ID, INDIVIDUAL_ID)\n",
    "create_incident_individual(INCIDENT_ID, PAYEE_ID)\n",
    "\n",
    "create_claim(NEW_CLAIM_ID, INCIDENT_ID, 4313)\n",
    "create_claim(CLAIM2_ID, INCIDENT_ID, 2500)\n",
    "create_injury(INJURY_ID, \"Legs\", NEW_CLAIM_ID, INDIVIDUAL_ID)\n",
    "create_payment(PAYMENT_ID, 4300, NEW_CLAIM_ID, INDIVIDUAL_ID, PAYEE_ID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1bd644c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['ind_count', 'amount_paid', 'num_frauds_community',\n",
      "       'num_frauds_neighborhood', 'influence', 'policy_premium_A',\n",
      "       'policy_premium_B', 'policy_premium_C', 'policy_premium_D',\n",
      "       'policy_premium_U'],\n",
      "      dtype='object')\n",
      "bc7462cb\n",
      "Claim bc7462cb fraud prediction: [False]\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>ind_count</th>\n",
       "      <th>amount_paid</th>\n",
       "      <th>num_frauds_community</th>\n",
       "      <th>num_frauds_neighborhood</th>\n",
       "      <th>influence</th>\n",
       "      <th>policy_premium_A</th>\n",
       "      <th>policy_premium_B</th>\n",
       "      <th>policy_premium_C</th>\n",
       "      <th>policy_premium_D</th>\n",
       "      <th>policy_premium_U</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>bc7462cb</th>\n",
       "      <td>0</td>\n",
       "      <td>4300.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000172</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          ind_count  amount_paid  num_frauds_community  \\\n",
       "bc7462cb          0       4300.0                     0   \n",
       "\n",
       "          num_frauds_neighborhood  influence  policy_premium_A  \\\n",
       "bc7462cb                        0   0.000172                 0   \n",
       "\n",
       "          policy_premium_B  policy_premium_C  policy_premium_D  \\\n",
       "bc7462cb                 0                 0                 0   \n",
       "\n",
       "          policy_premium_U  \n",
       "bc7462cb                 0  "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def extract_features(clm_id, columns):\n",
    "    X = pd.DataFrame({\n",
    "        FeatureStore.IND_COUNT: get_individual_count(clm_id),\n",
    "        FeatureStore.AMT_PAID: get_amount_paid(clm_id),\n",
    "        FeatureStore.NUM_FRAUDS_COMMUNITY: get_num_frauds_community(clm_id),\n",
    "        FeatureStore.NUM_FRAUDS_NEIGHBORHOOD: get_num_frauds_neighborhood(clm_id),\n",
    "        FeatureStore.INFLUENCE: get_influence(clm_id),\n",
    "    }, index=[clm_id])\n",
    "    # Selecting the feature type. \n",
    "    X = X.astype({\n",
    "        FeatureStore.IND_COUNT: int,\n",
    "        FeatureStore.AMT_PAID: float,\n",
    "        FeatureStore.NUM_FRAUDS_COMMUNITY: int,\n",
    "        FeatureStore.NUM_FRAUDS_NEIGHBORHOOD: int,\n",
    "        FeatureStore.INFLUENCE: float,\n",
    "    })\n",
    "    X = pd.get_dummies(X)\n",
    "    X = X.reindex(columns = columns, fill_value=0)\n",
    "    return X\n",
    "\n",
    "print(feature_columns)\n",
    "print(NEW_CLAIM_ID)\n",
    "new_features = extract_features(NEW_CLAIM_ID, feature_columns)\n",
    "y_pred=logistic_regression.predict(new_features)\n",
    "print(f\"Claim {NEW_CLAIM_ID} fraud prediction: {y_pred}\")\n",
    "new_features"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}