main_bpi2012.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import pandas as pd\n",
    "from pm4py.objects.log.util import dataframe_utils\n",
    "from pm4py.objects.conversion.log import converter as log_converter\n",
    "import networkx as nx\n",
    "from networkx.drawing.nx_agraph import graphviz_layout, to_agraph\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import copy\n",
    "\n",
    "import pygraphviz as pgv\n",
    "import json\n",
    "\n",
    "import pm4py\n",
    "\n",
    "from collections import Counter\n",
    "import subprocess\n",
    "\n",
    "from sklearn import mixture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# global variables\n",
    "SAVE_ELEMENTS = True # store generated elements\n",
    "\n",
    "#paths\n",
    "BPI_PATH = 'BPI_Challenge_2012.xes'\n",
    "BPI_PATH_PROCESSED = 'bpi2012.xes'\n",
    "ACTIVITIES_PATH = 'activities2012.xml'\n",
    "\n",
    "# log processing\n",
    "MIN_SPEAKING_TIME = 60\n",
    "DAY_DIFFERENCE = 10\n",
    "CLUSTER_COMPONENTS = 3\n",
    "\n",
    "# verfification\n",
    "VERIFYTA_PATH = \".../bin/verifyta\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "parsing log, completed traces :: 100%|██████████| 13087/13087 [00:06<00:00, 2152.44it/s]\n"
     ]
    }
   ],
   "source": [
    "# Load the log\n",
    "from pm4py.objects.log.importer.xes import importer as xes_importer\n",
    "log_application = xes_importer.apply(BPI_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# helpfer function to check if element is contained in trace\n",
    "def contains(trace, element):\n",
    "    for event in trace:\n",
    "        if event['concept:name']==element:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing\n",
    "\n",
    "In the preprocessing, we:\n",
    "- transform the log into a list format\n",
    "- discretise offer events\n",
    "- remove trivial events\n",
    "- remove incomplete and declines journeys\n",
    "- compute durations of calls\n",
    "- cluster call events "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# detect \"redundant\" events -> can be omitted\n",
    "for trace in log_application:\n",
    "    for i in range(len(trace)):\n",
    "        if trace[i]['concept:name'] == \"A_PARTLYSUBMITTED\":\n",
    "            assert(trace[i-1]['concept:name']== \"A_SUBMITTED\")\n",
    "\n",
    "        \"\"\"\n",
    "        # cant confirm from Bautista et al.\n",
    "        if trace[i]['concept:name'] == \"O_CANCELLED\":\n",
    "            if not (trace[i+1]['concept:name'] == \"A_CANCELLED\" or trace[i-1]['concept:name'] == \"A_CANCELLED\"):\n",
    "                print(trace[i-2]['concept:name'])\n",
    "                print(trace[i-1]['concept:name'])\n",
    "                print(trace[i]['concept:name'])\n",
    "                print(trace[i+1]['concept:name'])\n",
    "                print(trace[i+2]['concept:name'])\n",
    "            assert(trace[i+1]['concept:name']== \"A_CANCELLED\" or trace[i-1]['concept:name']== \"A_CANCELLED\")\n",
    "        \"\"\"\n",
    "\n",
    "        if trace[i]['concept:name'] == \"O_DECLINED\":\n",
    "            assert(trace[i+1]['concept:name']== \"A_DECLINED\" or trace[i-1]['concept:name']== \"A_DECLINED\")\n",
    "        \n",
    "        # in successfull traces always 4 events together; occur only in successfull traces\n",
    "        if contains(trace, \"A_APPROVED\"):\n",
    "            if trace[i]['concept:name'] == \"A_APPROVED\":\n",
    "                pos1 = 0\n",
    "                pos2 = 0\n",
    "                pos3 = 0\n",
    "\n",
    "                for j in range(len(trace)):\n",
    "                    if trace[j][\"concept:name\"] == \"O_ACCEPTED\":\n",
    "                        pos1 = j\n",
    "                for j in range(len(trace)):\n",
    "                    if trace[j][\"concept:name\"] == \"A_ACTIVATED\":\n",
    "                        pos2 = j\n",
    "                for j in range(len(trace)):\n",
    "                    if trace[j][\"concept:name\"] == \"A_REGISTERED\":\n",
    "                        pos3 = j\n",
    "\n",
    "                s = sorted([pos1, pos2, pos3, i])\n",
    "                assert(s[0] == s[1]-1 and s[1] == s[2]-1 and s[2] == s[3]-1 or not contains(trace, \"O_ACCEPTED\") and s[1] == s[2]-1 and s[2] == s[3]-1 ) \n",
    "                # in three cases is \"O_ACCEPTED\" not contained, but then are the offers also pre-accepted and the other three elements are in group\n",
    "        else:\n",
    "            assert(not contains(trace, \"A_APPROVED\"))\n",
    "            assert(not contains(trace, \"O_ACCEPTED\"))\n",
    "            assert(not contains(trace, \"A_ACTIVATED\"))\n",
    "            assert(not contains(trace, \"A_REGISTERED\"))\n",
    "        \n",
    "        if trace[i]['concept:name'] == \"O_CREATED\":\n",
    "            assert(trace[i+1]['concept:name']== \"O_SENT\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# investigate number of offers - has no event for \"sent offer\"\n",
    "# discretise single 0_CREATED and 0_SENT events\n",
    "for trace in log_application:\n",
    "    offer_count = -1\n",
    "    for e in trace:\n",
    "        if \"O_CREATED\" in e[\"concept:name\"]:\n",
    "            offer_count += 1\n",
    "            e[\"concept:name\"] += str(offer_count)\n",
    "\n",
    "        elif \"O_SENT\" in e[\"concept:name\"] and \"BACK\" not in e[\"concept:name\"]:\n",
    "            e[\"concept:name\"] += str(offer_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Different outcomes: {'A_DECLINED': 7635, 'A_CANCELLED': 2807, 'A_APPROVED': 2246, 'unclass': 399}\n",
      "Number of events 13087  number of accounted outcomes 13087\n"
     ]
    }
   ],
   "source": [
    "# Confirm findings from report on declined, cancelled, approved and unclassified traces.\n",
    "counts = {\"A_DECLINED\":0, \"A_CANCELLED\":0, \"A_APPROVED\":0, \"unclass\": 0}\n",
    "for trace in log_application:\n",
    "    found = False\n",
    "    for k in list(counts.keys()):\n",
    "        if contains(trace, k):\n",
    "            assert(not found)\n",
    "            found = True\n",
    "            counts[k] += 1\n",
    "    if not found:\n",
    "        counts[\"unclass\"] += 1\n",
    "\n",
    "print(\"Different outcomes:\", counts)\n",
    "print(\"Number of events\",len(log_application) ,\" number of accounted outcomes\", sum([counts[k] for k in counts.keys()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transform log into list format, log is represented as list of lists, easier removal and insertion of single events.\n",
    "def log_to_list(log):\n",
    "    transformed_log = []\n",
    "    for trace in log:\n",
    "        current_trace = []\n",
    "        for event in trace:\n",
    "            event['case:concept:name'] = trace.attributes['concept:name']\n",
    "            current_trace.append(event)\n",
    "        current_trace.insert(0, {\"concept:name\": \"start\", 'case:concept:name':trace.attributes['concept:name'], 'time:timestamp': trace[0]['time:timestamp']}) #insert start event\n",
    "        transformed_log.append(current_trace)\n",
    "    return transformed_log\n",
    "\n",
    "list_log_application = log_to_list(log_application)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Only cancelled and approved events are kept in the log, Final events are appended.\n",
    "def filter_incomplete_traces(log):\n",
    "    transformed_log = []\n",
    "    outcomes = [\"A_CANCELLED\", \"A_APPROVED\"] # \"A_DECLINED\",\n",
    "    for trace in log:\n",
    "        trace_copy = copy.deepcopy(trace)\n",
    "        contained = False\n",
    "        for o in outcomes:\n",
    "            if contains(trace, o):\n",
    "                contained = True\n",
    "        if contained:\n",
    "            if contains(trace, \"A_CANCELLED\"):\n",
    "                trace_copy.append({'concept:name': \"negative\", 'time:timestamp': trace[-1]['time:timestamp'], 'case:concept:name': trace[0]['case:concept:name']})\n",
    "            if contains(trace, \"A_APPROVED\"):\n",
    "                trace_copy.append({'concept:name': \"positive\", 'time:timestamp': trace[-1]['time:timestamp'], 'case:concept:name': trace[0]['case:concept:name']})\n",
    "            assert(contains(trace_copy, \"negative\") or contains(trace_copy, \"positive\"))\n",
    "            transformed_log.append(trace_copy)\n",
    "    return transformed_log\n",
    "\n",
    "list_log_application = filter_incomplete_traces(list_log_application)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variants before removing trivial elements\n",
      "3319\n"
     ]
    }
   ],
   "source": [
    "def variants(log):\n",
    "    element_list = []\n",
    "    for trace in log:\n",
    "        new_trace = [k[\"concept:name\"] for k in trace]\n",
    "        element_list.append(new_trace)\n",
    "    print(len(Counter(str(e) for e in element_list).keys()))\n",
    "\n",
    "print(\"Variants before removing trivial elements\")\n",
    "variants(list_log_application)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter events from log and compute durations of single calls\n",
    "def adjust_durations(log):\n",
    "    transformed_log = []\n",
    "    for trace in log:\n",
    "        new_trace  = []\n",
    "        for i in range(len(trace)):\n",
    "            if \"W_Nabellen\" in trace[i]['concept:name']: # omits SCHEDULE and COMPLETE call events\n",
    "                if trace[i]['lifecycle:transition']==\"START\":\n",
    "                    found = False\n",
    "                    duration = 0\n",
    "                    j = i\n",
    "                    while not found:\n",
    "                        j = j+1\n",
    "                        if j >= len(trace):\n",
    "                            for e in trace:\n",
    "                                print(e[\"concept:name\"], e['lifecycle:transition'])\n",
    "                        assert(j < len(trace))\n",
    "                        if trace[j]['concept:name'] == trace[i]['concept:name']:\n",
    "                            assert(trace[j]['lifecycle:transition'] != \"START\")\n",
    "                            if  trace[j]['lifecycle:transition']==\"COMPLETE\":\n",
    "                                found = True\n",
    "                                duration = (trace[j]['time:timestamp']-trace[i]['time:timestamp']).total_seconds()\n",
    "                        \n",
    "                    if duration > MIN_SPEAKING_TIME:\n",
    "                        if new_trace[-1][\"concept:name\"] == trace[i]['concept:name']: # merge call times together\n",
    "                            new_trace[-1][\"duration\"] += duration\n",
    "                        else:\n",
    "                            new_element = copy.deepcopy(trace[i])\n",
    "                            new_element[\"duration\"] = duration\n",
    "                            new_trace.append(new_element)\n",
    "            if trace[i]['concept:name'] == \"A_Cancelled\": #differentiate between user_abort and timeout\n",
    "                new_element = copy.deepcopy(trace[i])\n",
    "                if (trace[i]['time:timestamp']-trace[i-1]['time:timestamp']).days >= DAY_DIFFERENCE or (trace[i]['time:timestamp']-trace[i-2]['time:timestamp']).days >= TIMEOUT_THRESHOLD :\n",
    "                    new_element[-1]['concept:name'] = \"TIMEOUT\"\n",
    "                    assert(False) # no timeouts detected before cancellation\n",
    "                else:\n",
    "                    new_element[-1]['concept:name'] += \" CUSTOMER\"\n",
    "                new_trace.append(new_element)\n",
    "            else:\n",
    "                if \"W_\" in trace[i]['concept:name']:  # skip other workflow elements\n",
    "                    continue\n",
    "                if \"O_SELECTED\" in trace[i]['concept:name']:\n",
    "                    continue\n",
    "                if \"O_SENT\" in trace[i]['concept:name'] and \"BACK\" not in trace[i]['concept:name']: # skip sent event, but not send_back\n",
    "                    continue\n",
    "                elif \"O_DECLINED\" in trace[i]['concept:name'] or \"A_PARTLYSUBMITTED\" in trace[i]['concept:name']: # skip trivial elements\n",
    "                    continue\n",
    "                else:\n",
    "                    new_trace.append(trace[i])\n",
    "\n",
    "        transformed_log.append(new_trace)\n",
    "    return transformed_log\n",
    "\n",
    "list_log_application = adjust_durations(list_log_application)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to merge the 4 events present in successful logs: A_APPROVED, O_ACCEPTED, A_ACTIVATED and A_REGISTERED\n",
    "def merge_successful(log):\n",
    "    transformed_log = []\n",
    "    for trace in log:\n",
    "        if contains(trace, \"A_APPROVED\"):\n",
    "            modified_trace = copy.deepcopy(trace)\n",
    "\n",
    "            for j in range(len(modified_trace)):\n",
    "                if modified_trace[j][\"concept:name\"] == \"O_ACCEPTED\":\n",
    "                    modified_trace.pop(j)\n",
    "                    break\n",
    "\n",
    "            for j in range(len(modified_trace)):\n",
    "                if modified_trace[j][\"concept:name\"] == \"A_ACTIVATED\":\n",
    "                    modified_trace.pop(j)\n",
    "                    break\n",
    "            \n",
    "            for j in range(len(modified_trace)):\n",
    "                if modified_trace[j][\"concept:name\"] == \"A_REGISTERED\":\n",
    "                    modified_trace.pop(j)\n",
    "                    break\n",
    "            \n",
    "            transformed_log.append(modified_trace)\n",
    "\n",
    "        else:\n",
    "            transformed_log.append(trace)\n",
    "    return transformed_log\n",
    "\n",
    "list_log_application = merge_successful(list_log_application)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variants after removing trivial events\n",
      "202\n"
     ]
    }
   ],
   "source": [
    "print(\"Variants after removing trivial events\")\n",
    "variants(list_log_application)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Duration histogram for 'W_Nabellen offertes'\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAD4CAYAAAAZ1BptAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAUtElEQVR4nO3df6yeZ33f8fendhKqwohDziLPtmZDPVVmUk12FoJAFQOROGaag0SRo6qxWCR3WyKB1G112j9CoZFgGmRDgxSzeATECBk/FCtNm7ohVcUfJDkpxsQJWQ4hKLZMfMBJKEKNlvS7P57L6Ik5l31+POecJ/b7JT167vt7X/ePy/dzzsf3j+fcqSokSZrNr6z0BkiSxpchIUnqMiQkSV2GhCSpy5CQJHWtXukNOJ2LL764Nm7cuNKbIUmvKA8//PCPq2piFMsa65DYuHEjU1NTK70ZkvSKkuSHo1qWp5skSV2GhCSpy5CQJHUZEpKkLkNCktRlSEiSugwJSVKXISFJ6jIkJEldY/2N68XauOfPFjzvUx999wi3RJJemTySkCR1GRKSpC5DQpLUNeeQSLIqybeT3N3GNyV5IMl0ki8nOb/VL2jj0236xqFl3Njqjye5cuS9kSSN1HyOJD4APDY0/jHglqr6deBZ4LpWvw54ttVvae1IsgXYCbwR2AZ8OsmqxW2+JGkpzSkkkqwH3g38zzYe4B3AV1qT24Gr2/CONk6b/s7WfgdwR1W9UFU/AKaBy0bQB0nSEpnrkcR/A/4z8A9t/HXAc1X1Yhs/Aqxrw+uApwHa9Odb+1/UZ5nnF5LsTjKVZGpmZmbuPZEkjdwZQyLJvwaOV9XDy7A9VNXeqpqsqsmJiZE8fU+StEBz+TLdW4F/k2Q78CrgHwH/Hbgwyep2tLAeONraHwU2AEeSrAZeC/xkqH7S8DySpDF0xiOJqrqxqtZX1UYGF56/UVW/A9wPvLc12wXc1Yb3t3Ha9G9UVbX6znb30yZgM/DgyHoiSRq5xfxZjj8A7kjyJ8C3gdta/TbgC0mmgRMMgoWqOpzkTuBR4EXg+qp6aRHrlyQtsXmFRFX9NfDXbfhJZrk7qar+Hvjtzvw3AzfPdyMlSSvDb1xLkroMCUlSlyEhSeoyJCRJXYaEJKnLkJAkdRkSkqQuQ0KS1GVISJK6DAlJUpchIUnqMiQkSV2GhCSpy5CQJHUZEpKkLkNCktR1xpBI8qokDyb5TpLDSf641T+X5AdJDrbX1lZPkk8mmU5yKMmlQ8valeSJ9trVWaUkaUzM5cl0LwDvqKqfJTkP+GaSP2/T/lNVfeWU9lcxeH71ZuDNwK3Am5NcBNwETAIFPJxkf1U9O4qOSJJG74xHEjXwszZ6XnvVaWbZAXy+zfct4MIka4ErgQNVdaIFwwFg2+I2X5K0lOZ0TSLJqiQHgeMMftE/0Cbd3E4p3ZLkglZbBzw9NPuRVuvVT13X7iRTSaZmZmbm1xtJ0kjNKSSq6qWq2gqsBy5L8s+BG4HfAP4lcBHwB6PYoKraW1WTVTU5MTExikVKkhZoXnc3VdVzwP3Atqo61k4pvQD8L+Cy1uwosGFotvWt1qtLksbUXO5umkhyYRv+VeBdwPfadQaSBLgaeKTNsh+4tt3ldDnwfFUdA+4FrkiyJska4IpWkySNqbnc3bQWuD3JKgahcmdV3Z3kG0kmgAAHgX/X2t8DbAemgZ8D7weoqhNJPgI81Np9uKpOjKwnkqSRO2NIVNUh4E2z1N/RaV/A9Z1p+4B989xGSdIK8RvXkqQuQ0KS1GVISJK6DAlJUpchIUnqMiQkSV2GhCSpy5CQJHUZEpKkLkNCktRlSEiSugwJSVKXISFJ6jIkJEldhoQkqcuQkCR1zeXxpa9K8mCS7yQ5nOSPW31TkgeSTCf5cpLzW/2CNj7dpm8cWtaNrf54kiuXrFeSpJGYy5HEC8A7quo3ga3Atvbs6o8Bt1TVrwPPAte19tcBz7b6La0dSbYAO4E3AtuAT7dHokqSxtQZQ6IGftZGz2uvAt4BfKXVbweubsM72jht+juTpNXvqKoXquoHDJ6BfdkoOiFJWhpzuiaRZFWSg8Bx4ADwfeC5qnqxNTkCrGvD64CnAdr054HXDddnmWd4XbuTTCWZmpmZmXeHJEmjM6eQqKqXqmorsJ7B//5/Y6k2qKr2VtVkVU1OTEws1WokSXMwr7ubquo54H7gLcCFSVa3SeuBo234KLABoE1/LfCT4fos80iSxtBc7m6aSHJhG/5V4F3AYwzC4r2t2S7grja8v43Tpn+jqqrVd7a7nzYBm4EHR9QPSdISWH3mJqwFbm93Iv0KcGdV3Z3kUeCOJH8CfBu4rbW/DfhCkmngBIM7mqiqw0nuBB4FXgSur6qXRtsdSdIonTEkquoQ8KZZ6k8yy91JVfX3wG93lnUzcPP8N1OStBL8xrUkqcuQkCR1GRKSpC5DQpLUZUhIkroMCUlSlyEhSeoyJCRJXYaEJKnLkJAkdRkSkqQuQ0KS1GVISJK6DAlJUpchIUnqMiQkSV1zeXzphiT3J3k0yeEkH2j1DyU5muRge20fmufGJNNJHk9y5VB9W6tNJ9mzNF2SJI3KXB5f+iLw+1X1t0leAzyc5ECbdktV/dfhxkm2MHhk6RuBfwL8VZJ/1iZ/isEzso8ADyXZX1WPjqIjkqTRm8vjS48Bx9rw3yV5DFh3mll2AHdU1QvAD9qzrk8+5nS6PfaUJHe0toaEJI2peV2TSLKRwfOuH2ilG5IcSrIvyZpWWwc8PTTbkVbr1U9dx+4kU0mmZmZm5rN5kqQRm3NIJHk18FXgg1X1U+BW4A3AVgZHGh8fxQZV1d6qmqyqyYmJiVEsUpK0QHO5JkGS8xgExBer6msAVfXM0PTPAne30aPAhqHZ17cap6lLksbQXO5uCnAb8FhVfWKovnao2XuAR9rwfmBnkguSbAI2Aw8CDwGbk2xKcj6Di9v7R9MNSdJSmMuRxFuB3wW+m+Rgq/0hcE2SrUABTwG/B1BVh5PcyeCC9IvA9VX1EkCSG4B7gVXAvqo6PLKeSJJGbi53N30TyCyT7jnNPDcDN89Sv+d080mSxovfuJYkdRkSkqQuQ0KS1GVISJK6DAlJUpchIUnqMiQkSV2GhCSpy5CQJHUZEpKkLkNCktRlSEiSugwJSVKXISFJ6jIkJEldhoQkqWsujy/dkOT+JI8mOZzkA61+UZIDSZ5o72taPUk+mWQ6yaEklw4ta1dr/0SSXUvXLUnSKMzlSOJF4PeragtwOXB9ki3AHuC+qtoM3NfGAa5i8FzrzcBu4FYYhApwE/Bm4DLgppPBIkkaT2cMiao6VlV/24b/DngMWAfsAG5vzW4Hrm7DO4DP18C3gAuTrAWuBA5U1YmqehY4AGwbZWckSaM1r2sSSTYCbwIeAC6pqmNt0o+AS9rwOuDpodmOtFqvfuo6dieZSjI1MzMzn82TJI3YnEMiyauBrwIfrKqfDk+rqgJqFBtUVXurarKqJicmJkaxSEnSAs0pJJKcxyAgvlhVX2vlZ9ppJNr78VY/CmwYmn19q/XqkqQxNZe7mwLcBjxWVZ8YmrQfOHmH0i7grqH6te0up8uB59tpqXuBK5KsaResr2g1SdKYWj2HNm8Ffhf4bpKDrfaHwEeBO5NcB/wQeF+bdg+wHZgGfg68H6CqTiT5CPBQa/fhqjoxik5IkpbGGUOiqr4JpDP5nbO0L+D6zrL2Afvms4GSpJXjN64lSV2GhCSpy5CQJHUZEpKkLkNCktRlSEiSugwJSVKXISFJ6jIkJEldhoQkqcuQkCR1GRKSpC5DQpLUZUhIkroMCUlSlyEhSeqay+NL9yU5nuSRodqHkhxNcrC9tg9NuzHJdJLHk1w5VN/WatNJ9oy+K5KkUZvLkcTngG2z1G+pqq3tdQ9Aki3ATuCNbZ5PJ1mVZBXwKeAqYAtwTWsrSRpjc3l86d8k2TjH5e0A7qiqF4AfJJkGLmvTpqvqSYAkd7S2j85/kyVJy2Ux1yRuSHKonY5a02rrgKeH2hxptV79lyTZnWQqydTMzMwiNk+StFgLDYlbgTcAW4FjwMdHtUFVtbeqJqtqcmJiYlSLlSQtwBlPN82mqp45OZzks8DdbfQosGGo6fpW4zR1SdKYWtCRRJK1Q6PvAU7e+bQf2JnkgiSbgM3Ag8BDwOYkm5Kcz+Di9v6Fb7YkaTmc8UgiyZeAtwMXJzkC3AS8PclWoICngN8DqKrDSe5kcEH6ReD6qnqpLecG4F5gFbCvqg6PujOSpNGay91N18xSvu007W8Gbp6lfg9wz7y2TpK0ovzGtSSpy5CQJHUZEpKkLkNCktRlSEiSugwJSVKXISFJ6jIkJEldhoQkqcuQkCR1GRKSpC5DQpLUZUhIkroMCUlSlyEhSeoyJCRJXWcMiST7khxP8shQ7aIkB5I80d7XtHqSfDLJdJJDSS4dmmdXa/9Ekl1L0x1J0ijN5Ujic8C2U2p7gPuqajNwXxsHuIrBc603A7uBW2EQKgwee/pm4DLgppPBIkkaX2cMiar6G+DEKeUdwO1t+Hbg6qH652vgW8CFSdYCVwIHqupEVT0LHOCXg0eSNGYWek3ikqo61oZ/BFzShtcBTw+1O9JqvfovSbI7yVSSqZmZmQVuniRpFBZ94bqqCqgRbMvJ5e2tqsmqmpyYmBjVYiVJC7DQkHimnUaivR9v9aPAhqF261utV5ckjbGFhsR+4OQdSruAu4bq17a7nC4Hnm+npe4Frkiypl2wvqLVJEljbPWZGiT5EvB24OIkRxjcpfRR4M4k1wE/BN7Xmt8DbAemgZ8D7weoqhNJPgI81Np9uKpOvRguSRozZwyJqrqmM+mds7Qt4PrOcvYB++a1dZKkFeU3riVJXYaEJKnLkJAkdRkSkqQuQ0KS1GVISJK6DAlJUpchIUnqMiQkSV2GhCSpy5CQJHUZEpKkLkNCktRlSEiSugwJSVKXISFJ6lpUSCR5Ksl3kxxMMtVqFyU5kOSJ9r6m1ZPkk0mmkxxKcukoOiBJWjqjOJL4V1W1taom2/ge4L6q2gzc18YBrgI2t9du4NYRrFuStISW4nTTDuD2Nnw7cPVQ/fM18C3gwiRrl2D9kqQRWWxIFPCXSR5OsrvVLqmqY234R8AlbXgd8PTQvEda7WWS7E4ylWRqZmZmkZsnSVqM1Yuc/21VdTTJPwYOJPne8MSqqiQ1nwVW1V5gL8Dk5OS85pUkjdaijiSq6mh7Pw58HbgMeObkaaT2frw1PwpsGJp9fatJksbUgkMiya8lec3JYeAK4BFgP7CrNdsF3NWG9wPXtrucLgeeHzotJUkaQ4s53XQJ8PUkJ5fzv6vqL5I8BNyZ5Drgh8D7Wvt7gO3ANPBz4P2LWLckaRksOCSq6kngN2ep/wR45yz1Aq5f6PokScvPb1xLkroMCUlSlyEhSeoyJCRJXYaEJKnLkJAkdRkSkqQuQ0KS1GVISJK6DAlJUpchIUnqMiQkSV2GhCSpy5CQJHUZEpKkLkNCktS17CGRZFuSx5NMJ9mz3OuXJM3dsoZEklXAp4CrgC3ANUm2LOc2SJLmbjHPuF6Iy4Dp9uhTktwB7AAeXebtOKONe/5spTfhFeWpj757pTdBmtVK/iyfDT8Xyx0S64Cnh8aPAG8ebpBkN7C7jf4syeOLWN/FwI8XMf8r1bL3Ox9bzrWdlvv83DO2fV+Gn4te3//pqFaw3CFxRlW1F9g7imUlmaqqyVEs65XkXO03nLt9P1f7DfZ9qfu+3BeujwIbhsbXt5okaQwtd0g8BGxOsinJ+cBOYP8yb4MkaY6W9XRTVb2Y5AbgXmAVsK+qDi/hKkdy2uoV6FztN5y7fT9X+w32fUmlqpZ6HZKkVyi/cS1J6jIkJEldZ2VInC1/+iPJU0m+m+RgkqlWuyjJgSRPtPc1rZ4kn2x9PpTk0qHl7Grtn0iya6j+L9ryp9u8Wf5e/mJb9iU5nuSRodqS97W3juXU6fuHkhxt+/5gku1D025s/Xg8yZVD9Vk/9+1GkQda/cvtphGSXNDGp9v0jcvU5ZPbtSHJ/UkeTXI4yQda/aze76fp93ju86o6q14MLoh/H3g9cD7wHWDLSm/XAvvyFHDxKbX/Auxpw3uAj7Xh7cCfAwEuBx5o9YuAJ9v7mja8pk17sLVNm/eqFezrbwGXAo8sZ1976xiDvn8I+I+ztN3SPtMXAJvaZ33V6T73wJ3Azjb8p8C/b8P/AfjTNrwT+PIy93stcGkbfg3wf1v/zur9fpp+j+U+X5FfCEu8A94C3Ds0fiNw40pv1wL78hS/HBKPA2uHPmyPt+HPANec2g64BvjMUP0zrbYW+N5Q/WXtVqi/G3n5L8ol72tvHWPQ994vjJd9nhncKfiW3ue+/XL8MbC61X/R7uS8bXh1a5cV3P93Ae86l/b7Kf0ey31+Np5umu1Pf6xboW1ZrAL+MsnDGfy5EoBLqupYG/4RcEkb7vX7dPUjs9THyXL0tbeOcXBDO62yb+h0yHz7/jrguap68ZT6y5bVpj/f2i+7dtrjTcADnEP7/ZR+wxju87MxJM4mb6uqSxn81dzrk/zW8MQa/HfgnLiHeTn6Omb/nrcCbwC2AseAj6/o1iyhJK8Gvgp8sKp+OjztbN7vs/R7LPf52RgSZ82f/qiqo+39OPB1Bn9F95kkawHa+/HWvNfv09XXz1IfJ8vR1946VlRVPVNVL1XVPwCfZbDvYf59/wlwYZLVp9Rftqw2/bWt/bJJch6DX5RfrKqvtfJZv99n6/e47vOzMSTOij/9keTXkrzm5DBwBfAIg76cvHtjF4PzmbT6te0OkMuB59vh9L3AFUnWtMPXKxicnzwG/DTJ5e2Oj2uHljUulqOvvXWsqJO/wJr3MNj3MNjene0ulU3AZgYXZ2f93Lf/Jd8PvLfNf+q/48m+vxf4Rmu/LNq+uA14rKo+MTTprN7vvX6P7T5fqYs1S3whaDuDOwa+D/zRSm/PAvvwegZ3K3wHOHyyHwzOH94HPAH8FXBRq4fBA52+D3wXmBxa1r8Fptvr/UP1yfZB/D7wP1jZi5ZfYnCI/f8YnEO9bjn62lvHGPT9C61vh9oP9tqh9n/U+vE4Q3ek9T737bP0YPs3+T/ABa3+qjY+3aa/fpn7/TYGp3kOAQfba/vZvt9P0++x3Of+WQ5JUtfZeLpJkjQihoQkqcuQkCR1GRKSpC5DQpLUZUhIkroMCUlS1/8HXvkvWuVEd1EAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Duration histogram for 'W_Nabellen incomplete dossiers'\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# investigate response times\n",
    "response_times = {}\n",
    "for trace in list_log_application:\n",
    "    for e in trace:\n",
    "        if \"W_Nabellen\" in e['concept:name']:\n",
    "            if e['concept:name'] not in response_times:\n",
    "                response_times[e['concept:name']] = []\n",
    "            response_times[e['concept:name']].append(e['duration'])\n",
    "print(\"Duration histogram for 'W_Nabellen offertes'\")\n",
    "plt.hist(response_times['W_Nabellen offertes'], 20)\n",
    "plt.show()\n",
    "print(\"Duration histogram for 'W_Nabellen incomplete dossiers'\")\n",
    "plt.hist(response_times['W_Nabellen incomplete dossiers'], 20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "A_SUBMITTED\n",
      "A_PREACCEPTED\n",
      "A_ACCEPTED\n",
      "A_FINALIZED\n",
      "O_CREATED0\n",
      "W_Nabellen offertes\n",
      "O_SENT_BACK\n",
      "A_APPROVED\n",
      "positive\n",
      "####\n",
      "start\n",
      "A_SUBMITTED\n",
      "A_PREACCEPTED\n",
      "A_ACCEPTED\n",
      "A_FINALIZED\n",
      "O_CREATED0\n",
      "W_Nabellen offertes#0\n",
      "O_SENT_BACK\n",
      "A_APPROVED\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "# Cluster call events based on call durations by Bayesian-Gaussian mixture clustering\n",
    "def get_bayesian_gaussian_mixture(components, times):\n",
    "    duration_classifier = {}\n",
    "    for t in times:\n",
    "        if len(times[t])==1:\n",
    "            g = mixture.BayesianGaussianMixture(n_components=1,covariance_type='full')\n",
    "            g.fit(np.array([[times[t]], [times[t]]]).reshape(-1, 1))\n",
    "            duration_classifier[t] = g\n",
    "            continue\n",
    "        \n",
    "        g = mixture.BayesianGaussianMixture(n_components=components,covariance_type='full', random_state=42)\n",
    "        g.fit(np.array(times[t]).reshape(-1,1))\n",
    "        duration_classifier[t] = g\n",
    "    return duration_classifier\n",
    "\n",
    "def classify_log(log, predictor):\n",
    "    log = copy.deepcopy(log)\n",
    "    for trace in log:\n",
    "        for pos in range(1,len(trace)):\n",
    "            action = trace[pos][\"concept:name\"]\n",
    "            if \"W_Nabellen\" not in action:\n",
    "                continue\n",
    "            assert(\"duration\" in trace[pos])\n",
    "            duration = trace[pos][\"duration\"]\n",
    "            suffix = str(predictor[action].predict(np.array(duration).reshape(1,-1))[0])\n",
    "            assert(int(suffix) in list(range(0,100)))\n",
    "            trace[pos][\"concept:name\"] += \"#\"+suffix\n",
    "\n",
    "    return log\n",
    "\n",
    "for e in list_log_application[0]:\n",
    "    print(e[\"concept:name\"])\n",
    "print(\"####\")\n",
    "\n",
    "predictor = get_bayesian_gaussian_mixture(CLUSTER_COMPONENTS, response_times)\n",
    "list_log_application = classify_log(list_log_application, predictor)\n",
    "\n",
    "for e in list_log_application[0]:\n",
    "    print(e[\"concept:name\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Log Properties\n",
    "We investigate certain log properties differentiating the BPIC'17 event log from BPIC'12.\n",
    "It shows that not only the average number of calls but also the average number of generated offers were significantly changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of calls in successful journeys {'W_Nabellen incomplete': 0.6282279608192342, 'W_Nabellen offertes': 1.0031166518254675}\n",
      "Average number of calls in unsuccessful journeys {'W_Nabellen incomplete': 0.05949412183826149, 'W_Nabellen offertes': 0.7011043819023869}\n",
      "Average number of calls in all journeys {'W_Nabellen incomplete': 0.3122897288739363, 'W_Nabellen offertes': 0.8353453394023352}\n"
     ]
    }
   ],
   "source": [
    "# investigate avg. number of calls in trace\n",
    "counts_positive = {\"W_Nabellen incomplete\" : 0, \"W_Nabellen offertes\":0}\n",
    "pos_count = 0\n",
    "for trace in list_log_application:\n",
    "    if contains(trace, \"positive\") :\n",
    "        pos_count += 1\n",
    "        for e in trace:\n",
    "            if \"W_Nabellen incomplete\" in e['concept:name']:\n",
    "                counts_positive[\"W_Nabellen incomplete\"] += 1\n",
    "            if \"W_Nabellen offertes\" in e['concept:name']:\n",
    "                counts_positive['W_Nabellen offertes'] += 1\n",
    "\n",
    "counts_negative = {\"W_Nabellen incomplete\" : 0, \"W_Nabellen offertes\":0}\n",
    "neg_count = 0\n",
    "for trace in list_log_application:\n",
    "    if contains(trace, \"negative\") :\n",
    "        neg_count += 1\n",
    "        for e in trace:\n",
    "            if \"W_Nabellen incomplete\" in e['concept:name']:\n",
    "                counts_negative[\"W_Nabellen incomplete\"] += 1\n",
    "            if \"W_Nabellen offertes\" in e['concept:name']:\n",
    "                counts_negative['W_Nabellen offertes'] += 1\n",
    "\n",
    "both = {\"W_Nabellen incomplete\" : 0, \"W_Nabellen offertes\":0}\n",
    "for k in counts_positive:\n",
    "    both[k] = (counts_negative[k] + counts_positive[k])/(neg_count+pos_count)\n",
    "\n",
    "for k in counts_positive:\n",
    "    counts_positive[k] /= pos_count\n",
    "for k in counts_negative:\n",
    "    counts_negative[k] /= neg_count\n",
    "\n",
    "\n",
    "print(\"Average number of calls in successful journeys\", counts_positive)\n",
    "print(\"Average number of calls in unsuccessful journeys\", counts_negative)\n",
    "print(\"Average number of calls in all journeys\", both)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of created offers in successful journeys 1.4804096170970615\n",
      "Average number of created offers in unsuccessful journeys 0.7759173494834343\n",
      "Average number of created offers in all journeys 1.0890560063328716\n"
     ]
    }
   ],
   "source": [
    "# Investigate the average number of created offers\n",
    "counts_pos = []\n",
    "counts_neg = []\n",
    "for trace in list_log_application:\n",
    "    count = 0\n",
    "    if contains(trace, \"positive\") :\n",
    "        for e in trace:\n",
    "            if \"O_CREATED\" in e['concept:name']:\n",
    "                count += 1\n",
    "        counts_pos.append(count)\n",
    "    if contains(trace, \"negative\") :\n",
    "        for e in trace:\n",
    "            if \"O_CREATED\" in e['concept:name']:\n",
    "                count += 1\n",
    "        counts_neg.append(count)\n",
    "print(\"Average number of created offers in successful journeys\", sum(counts_pos)/len(counts_pos))\n",
    "print(\"Average number of created offers in unsuccessful journeys\", sum(counts_neg)/len(counts_neg))\n",
    "\n",
    "counts = []\n",
    "for trace in list_log_application:\n",
    "    count = 0\n",
    "    for e in trace:\n",
    "        if \"O_CREATED\" in e['concept:name']:\n",
    "            count += 1\n",
    "    counts.append(count)\n",
    "print(\"Average number of created offers in all journeys\", sum(counts)/len(counts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "exporting log, completed traces :: 100%|██████████| 5053/5053 [00:00<00:00, 5351.99it/s]\n"
     ]
    }
   ],
   "source": [
    "# export the log for easier further analysis\n",
    "def export(log, path):\n",
    "    # to use the pm4py write_xes function, an pm4py event log object is needed.\n",
    "    # for this is the list event log via the pandas data frame to a pm4py event log converted.\n",
    "    log_df = pd.DataFrame()\n",
    "    for trace in log:\n",
    "        assert(trace[0][\"concept:name\"]==\"start\")\n",
    "        assert(contains(trace, \"negative\") or contains(trace, \"positive\"))\n",
    "        log_df = log_df.append(trace, ignore_index=True)\n",
    "\n",
    "    event_log = pm4py.convert_to_event_log(log_df)\n",
    "    pm4py.write_xes(event_log, path) \n",
    "\n",
    "if SAVE_ELEMENTS:\n",
    "    export(list_log_application, BPI_PATH_PROCESSED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3752.31it/s]\n"
     ]
    }
   ],
   "source": [
    "import_log = xes_importer.apply(BPI_PATH_PROCESSED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for trace_index in range(len(import_log)):\n",
    "    trace = import_log[trace_index]\n",
    "    if trace[0]['concept:name']!=\"start\":\n",
    "        for e in trace:\n",
    "            print(e['concept:name'])\n",
    "    assert(trace[0]['concept:name']==\"start\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process Model Construction\n",
    "The process model is build with the published decision boundary tool.\n",
    "We iterate over different settings to find the most promising one.\n",
    "The final model uses the muli-set abstraction with a history of 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3567.75it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 2988.60it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3240.83it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3360.32it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3354.02it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3292.61it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3301.78it/s]\n",
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3365.18it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abstraction multiset\n",
      "History: 3 Loops: 175666 Nodes: 177\n",
      "History: 4 Loops: 51746 Nodes: 316\n",
      "History: 5 Loops: 2 Nodes: 449\n",
      "History: 6 Loops: 6 Nodes: 560\n",
      "Abstraction sequence\n",
      "History: 3 Loops: 3500 Nodes: 254\n",
      "History: 4 Loops: 94 Nodes: 471\n",
      "History: 5 Loops: 0 Nodes: 706\n",
      "History: 6 Loops: 0 Nodes: 894\n"
     ]
    }
   ],
   "source": [
    "def compare(xes, activities, start = 3):\n",
    "    r = []\n",
    "    for type in [\"multiset\", \"sequence\"]:\n",
    "        r.append(\"Abstraction \"+ type)\n",
    "        for hist in range(start,7):\n",
    "            # use granular tool to build process models\n",
    "            o = subprocess.check_output([\"python3\", \"cli/process_model.py\", xes, \"cli/\", \"-t\", type, \"-hist\" , str(hist)])\n",
    "            f = str(o).replace(\"\\\\n'\", '').split(\"Generated: \")[-1]\n",
    "            o = subprocess.check_output([\"python3\", \"cli/build_game.py\", f, \"cli/\", activities])\n",
    "            f = str(o).replace(\"\\\\n'\", '').split(\"Generated: \")[-1]\n",
    "            inner_graph = nx.read_gexf(f)\n",
    "            r.append(\"History: \"+ str(hist)+ \" Loops: \"+str(len(list(nx.simple_cycles(inner_graph)))) + \" Nodes: \" +str(len(inner_graph.nodes())))\n",
    "    return r\n",
    "\n",
    "for e in compare(BPI_PATH_PROCESSED, ACTIVITIES_PATH):\n",
    "    print(e)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Boundary Analysis\n",
    "The decision boundary of the process model with the multi-set abstraction and history of 5 is analysed.\n",
    "In the accompanying paper we compare the properties of the BPIC'12 decision boundary with the ones from BPIC'17."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "parsing log, completed traces :: 100%|██████████| 5053/5053 [00:01<00:00, 3398.66it/s]\n"
     ]
    }
   ],
   "source": [
    "#  Build process model\n",
    "output = subprocess.check_output([\"python3\", \"cli/process_model.py\", BPI_PATH_PROCESSED, \"cli/\", \"-t\", \"multiset\", \"-hist\" , \"5\"])\n",
    "file_name = str(output).replace(\"\\\\n'\", '').split(\"Generated: \")[-1]\n",
    "# Build user journey game\n",
    "output = subprocess.check_output([\"python3\", \"cli/build_game.py\", file_name, \"cli/\", ACTIVITIES_PATH])\n",
    "file_name = str(output).replace(\"\\\\n'\", '').split(\"Generated: \")[-1]\n",
    "g = nx.read_gexf(file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plotted bpi2012.ps\n"
     ]
    }
   ],
   "source": [
    "def draw_dfg(g, name, layout = \"sfdp\"):\n",
    "    A = to_agraph(g)\n",
    "    edge_weights = nx.get_edge_attributes(g,'cost')\n",
    "    scaling = 10\n",
    "    for e in edge_weights:\n",
    "        e = A.get_edge(e[0], e[1])\n",
    "        #e.attr[\"penwidth\"] = edge_weights[e]*scaling\n",
    "        e.attr[\"fontsize\"] = \"20\"\n",
    "        e.attr[\"label\"] = edge_weights[e]\n",
    "    for e in g.edges:\n",
    "        if 'controllable' in g[e[0]][e[1]]:\n",
    "            if not g[e[0]][e[1]]['controllable']:\n",
    "                edge = A.get_edge(e[0], e[1])\n",
    "                edge.attr[\"style\"] = \"dotted\"\n",
    "\n",
    "    for s in g.nodes:\n",
    "        if \"decision_boundary\" in g.nodes[s]:\n",
    "            if g.nodes[s][\"decision_boundary\"]:\n",
    "                g.nodes[s]['color'] = \"blue\"\n",
    "    A.write(name.split(\".\")[0]+\".dot\")\n",
    "    A.layout(layout)\n",
    "    print(\"Plotted\", name)\n",
    "    A.draw(name)\n",
    "\n",
    "# plot process model for analysis\n",
    "if SAVE_ELEMENTS:\n",
    "    draw_dfg(g, \"bpi2012.ps\", \"dot\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct decision boundary\n",
    "output = subprocess.check_output([\"python3\", \"cli/decision_boundary.py\", file_name, \"cli/\", VERIFYTA_PATH, \"-q\", \"cli/guaranteed_tool.q\"])\n",
    "file_name = str(output).replace(\"\\\\n'\", '').split(\"Generated: \")[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apply reduction\n",
    "output = subprocess.check_output([\"python3\", \"cli/decision_boundary_reduction.py\", file_name, \"cli/\"])\n",
    "file_name = str(output).replace(\"\\\\n'\", '').split(\"Generated: \")[-1]\n",
    "\n",
    "g_dec_boundary = nx.read_gexf(file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"A_FINALIZED\": 1, \"O_CREATED0\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#1\": 1, \"W_Nabellen offertes#0\": 1}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED4\": 1, \"W_Nabellen offertes#0\": 1, \"W_Nabellen offertes#2\": 1}\n",
      "{\"A_ACCEPTED\": 1, \"A_FINALIZED\": 1, \"O_CREATED0\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#1\": 1}\n",
      "{\"O_CANCELLED\": 1, \"O_CREATED2\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#0\": 1, \"W_Nabellen incomplete dossiers#2\": 1}\n",
      "{\"O_CANCELLED\": 1, \"O_CREATED2\": 1, \"O_SENT_BACK\": 2, \"W_Nabellen incomplete dossiers#2\": 1}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED5\": 1, \"W_Nabellen incomplete dossiers#0\": 2}\n",
      "{\"O_CANCELLED\": 1, \"O_CREATED3\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#2\": 1, \"W_Nabellen offertes#0\": 1}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED4\": 1, \"W_Nabellen offertes#0\": 2}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED4\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen offertes#0\": 1}\n",
      "States in decision boundary 9\n"
     ]
    }
   ],
   "source": [
    "# function to retreive decision boundary states from \n",
    "def get_dec_bound(g):\n",
    "    bound = []\n",
    "    for s in g.nodes:\n",
    "        if \"decision_boundary\" in g.nodes[s]:\n",
    "            if g.nodes[s][\"decision_boundary\"]:\n",
    "                bound.append(s)\n",
    "                print(s)\n",
    "    return bound\n",
    "\n",
    "bound = get_dec_bound(g_dec_boundary)\n",
    "print(\"States in decision boundary\", len(bound))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bound contains no element with no call (\"W_Nabellen\")\n",
    "for n in bound:\n",
    "    if \"W_Nabellen\" not in n:\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "States with one cancellations\n",
      "{\"O_CANCELLED\": 1, \"O_CREATED2\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#0\": 1, \"W_Nabellen incomplete dossiers#2\": 1}\n",
      "{\"O_CANCELLED\": 1, \"O_CREATED2\": 1, \"O_SENT_BACK\": 2, \"W_Nabellen incomplete dossiers#2\": 1}\n",
      "{\"O_CANCELLED\": 1, \"O_CREATED3\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#2\": 1, \"W_Nabellen offertes#0\": 1}\n",
      "\n",
      "States with two cancellations\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED4\": 1, \"W_Nabellen offertes#0\": 1, \"W_Nabellen offertes#2\": 1}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED5\": 1, \"W_Nabellen incomplete dossiers#0\": 2}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED4\": 1, \"W_Nabellen offertes#0\": 2}\n",
      "{\"O_CANCELLED\": 2, \"O_CREATED4\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen offertes#0\": 1}\n",
      "\n",
      "States with no cancellations\n",
      "{\"A_FINALIZED\": 1, \"O_CREATED0\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#1\": 1, \"W_Nabellen offertes#0\": 1}\n",
      "{\"A_ACCEPTED\": 1, \"A_FINALIZED\": 1, \"O_CREATED0\": 1, \"O_SENT_BACK\": 1, \"W_Nabellen incomplete dossiers#1\": 1}\n"
     ]
    }
   ],
   "source": [
    "print(\"States with one cancellations\")\n",
    "for n in bound:\n",
    "    if '\"O_CANCELLED\": 1' in n:\n",
    "        print(n)\n",
    "print()\n",
    "print(\"States with two cancellations\")\n",
    "for n in bound:\n",
    "    if '\"O_CANCELLED\": 2' in n:\n",
    "        print(n)\n",
    "print()\n",
    "print(\"States with no cancellations\")\n",
    "for n in bound:\n",
    "    if \"O_CANCELLED\" not in n:\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_set(bound):\n",
    "    bounds = []\n",
    "    for n in bound:\n",
    "        b = {}\n",
    "        n = n.replace(\"{\",\"\")\n",
    "        n = n.replace(\"}\",\"\")\n",
    "        n = n.replace('\"',\"\")\n",
    "        n = n.replace(' ',\"\")\n",
    "        s = n.split(\",\")\n",
    "        for e in s:\n",
    "            s1 = e.split(\":\")\n",
    "            b[s1[0]] = int(s1[-1])\n",
    "        bounds.append(b)\n",
    "    return bounds\n",
    "bounds = to_set(bound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dist(s,t):\n",
    "    not_contained = 0\n",
    "    for k in s:\n",
    "        if k not in t:\n",
    "            not_contained += 1\n",
    "        elif s[k] != t[k]:\n",
    "            not_contained += abs(s[k]-t[k])\n",
    "    return not_contained\n",
    "\n",
    "def build_dec_bound_graph(bounds):\n",
    "    g = nx.Graph()\n",
    "    for s in bounds:\n",
    "        g.add_node(str(s))\n",
    "    for s in bounds:\n",
    "        for t in bounds:\n",
    "            if s == t:\n",
    "                continue\n",
    "            if dist(s,t) <= 1:\n",
    "                g.add_edge(str(s),str(t))\n",
    "    return g\n",
    "g = build_dec_bound_graph(bounds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# allows to plot the decision boundary as independent graph and analyse the cancellation clusters; requires that input models are in multi-set form\n",
    "# (not part of publication)\n",
    "def cluster_contains(c, s):\n",
    "    for e in c:\n",
    "        if s not in e:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def analyse_decision_boundary(file_name, name):\n",
    "    g_dec_boundary = nx.read_gexf(file_name)\n",
    "    bound = get_dec_bound(g_dec_boundary)\n",
    "    bounds = to_set(bound)\n",
    "    g = build_dec_bound_graph(bounds)\n",
    "\n",
    "    A = to_agraph(g)\n",
    "\n",
    "    count = 0\n",
    "    for c in nx.connected_components(g):\n",
    "        print(list(c)[0])\n",
    "        print(len(c))\n",
    "\n",
    "        label = \"0\" if not cluster_contains(c,\"O_CANCELLED\") else \"1\" if cluster_contains(c,\"'O_CANCELLED': 1\") else \"2\"\n",
    "        \n",
    "        if label == \"0\":\n",
    "            assert(not cluster_contains(c,\"'O_CANCELLED': 1\"))\n",
    "            assert(not cluster_contains(c,\"'O_CANCELLED': 2\"))\n",
    "\n",
    "        if label == \"1\":\n",
    "            assert(not cluster_contains(c,\"'O_CANCELLED': 2\"))\n",
    "\n",
    "        if label == \"2\":\n",
    "            assert(not cluster_contains(c,\"'O_CANCELLED': 1\"))\n",
    "\n",
    "        colors = [\"blue\", \"red\", \"orange\"]\n",
    "        A.add_subgraph(c, name='cluster_'+str(count), label= \"#\"+label, color = colors[int(label)], fontsize = 60, fontcolor = colors[int(label)])\n",
    "\n",
    "        count+=1\n",
    "\n",
    "    for n in A.nodes():\n",
    "        n.attr['penwidth'] = 5\n",
    "        n.attr[\"label\"] = \"\"\n",
    "\n",
    "    A.layout(\"dot\")\n",
    "    print(\"Plotted\", name)\n",
    "    A.draw(name)\n",
    "    \n",
    "    nx.draw(g, node_size=80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plotted clustered_2012.png\n"
     ]
    }
   ],
   "source": [
    "# produces Figure 6 in the publication - reduced decision boundary plot\n",
    "def draw_dfg_cluster(g, name, layout = \"sfdp\"):\n",
    "\n",
    "    # color graph\n",
    "    for s in g:\n",
    "        outgoing_sum = 0\n",
    "        if \"color\" in g.nodes[s]:\n",
    "            if g.nodes[s]['color'] == \"blue\":\n",
    "                    continue\n",
    "        for n in g[s]:\n",
    "            if \"cost\" in g[s][n]:\n",
    "                outgoing_sum += g[s][n][\"cost\"]\n",
    "        if outgoing_sum >= 16:\n",
    "            g.nodes[s]['color'] = \"#0ead69\"\n",
    "        elif outgoing_sum <= -30:\n",
    "            g.nodes[s]['color'] = \"#9a031e\"\n",
    "        else:\n",
    "            g.nodes[s]['color'] = \"grey\"\n",
    "            \n",
    "    A = to_agraph(g)\n",
    "    edge_weights = nx.get_edge_attributes(g,'cost')\n",
    "    scaling = 10\n",
    "    for e in edge_weights:\n",
    "        e = A.get_edge(e[0], e[1])\n",
    "        e.attr[\"penwidth\"] = \"15\"\n",
    "        e.attr[\"fontsize\"] = \"20\"\n",
    "        e.attr[\"label\"] = \"\"\n",
    "        e.attr[\"color\"] = \"red\" if edge_weights[e] < 0 else \"green\"\n",
    "    for e in g.edges:\n",
    "        if 'controllable' in g[e[0]][e[1]]:\n",
    "            if not g[e[0]][e[1]]['controllable']:\n",
    "                edge = A.get_edge(e[0], e[1])\n",
    "                edge.attr[\"style\"] = \"dotted\"\n",
    "        \n",
    "    clusters = {\"0\": [], \"1\": [], \"2\":[]}\n",
    "    for s in A.nodes():\n",
    "        if \"decision_boundary\" in s.attr:\n",
    "            if s.attr[\"decision_boundary\"] == \"True\":\n",
    "                s.attr['color'] = \"blue\"\n",
    "                \n",
    "                c = \"0\" if not \"O_CANCELLED\" in s else \"1\" if '\"O_CANCELLED\": 1' in s else \"2\"\n",
    "                clusters[c].append(s)\n",
    "\n",
    "    count = 0\n",
    "    for n in A.nodes():\n",
    "        n.attr['fontsize'] = 100\n",
    "        n.attr['penwidth'] = 20\n",
    "        n.attr['height'] = 2\n",
    "        n.attr['width'] = 2\n",
    "        if n == \"pos\":\n",
    "            n.attr['color'] = \"#0ead69\"\n",
    "            n.attr['fontcolor'] = \"#0ead69\"\n",
    "            n.attr['label'] = 'Cpos'\n",
    "        if n == \"neg\":\n",
    "            n.attr['color'] = \"#9a031e\"\n",
    "            n.attr['fontcolor'] = \"#9a031e\"\n",
    "            n.attr['label'] = 'Cneg'\n",
    "        \n",
    "            \n",
    "        if n not in [\"pos\", \"neg\"]:\n",
    "            n.attr['label'] = \"\"\n",
    "    \n",
    "    A.layout(layout)\n",
    "    print(\"Plotted\", name)\n",
    "    A.draw(name)\n",
    "\n",
    "def get_connection(g):\n",
    "    for s in g:\n",
    "        if len(list(g[s]))!= 1:\n",
    "            continue\n",
    "        assert(len(list(g[s]))==1)\n",
    "        v = list(g[s])[0]\n",
    "\n",
    "        edges = list(g.in_edges(v))\n",
    "        if len(edges) == 1:\n",
    "            s1 = edges[0][0]\n",
    "            v1 = edges[0][1]\n",
    "            assert(s == s1 and v == v1)\n",
    "            return (s,v)\n",
    "    return None\n",
    "\n",
    "# Function to merge all 1:1 edges, produces a smaller plot\n",
    "def merge_connections(g):\n",
    "    g = copy.deepcopy(g)\n",
    "    \n",
    "    edge = get_connection(g)\n",
    "    while(edge != None):\n",
    "        g = nx.contracted_nodes(g, edge[1], edge[0])\n",
    "        g.remove_edges_from(nx.selfloop_edges(g))\n",
    "        edge = get_connection(g)\n",
    "        \n",
    "    return g\n",
    "\n",
    "if SAVE_ELEMENTS:\n",
    "    to_draw = nx.read_gexf(file_name)\n",
    "    to_draw = merge_connections(to_draw)\n",
    "    draw_dfg_cluster(to_draw, \"clustered_2012.png\", layout = \"dot\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dimension Reduction\n",
    "We investigate the applicability of the decision boundary as dimension reduction technique.\n",
    "When interpreting single events as features, many events are highly correlated.\n",
    "For instance, when entering the positive or negative cluster the outcome is determined and many events are thus positively correlated.\n",
    "When removing the events contained in the decision boundary, the present correlations reduce drastically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ms(trace):\n",
    "    multiset = {}\n",
    "    for pos in trace:\n",
    "        if pos['concept:name'] not in multiset:\n",
    "            multiset[pos['concept:name']] = 1\n",
    "        else:\n",
    "            multiset[pos['concept:name']] += 1\n",
    "    return json.dumps(multiset, sort_keys=True).encode().decode(\"utf-8\") # use json encodings for multisets\n",
    "\n",
    "def hist(trace): \n",
    "    hist = str(trace[0]['concept:name'])\n",
    "    for pos in trace[1:]:\n",
    "        hist += \" - \" + str(pos['concept:name']) # construct history\n",
    "    return hist\n",
    "\n",
    "def to_df(log, file_name, abstraction_history):\n",
    "    system = nx.read_gexf(file_name)\n",
    "    trace_df = pd.DataFrame(columns = list(system.edges()).append(\"y\"))\n",
    "    for trace in log:\n",
    "        trace_edges = [x['concept:name'] for x in trace]\n",
    "        data = {}\n",
    "        s = \"start\"\n",
    "        assert(trace[0]['concept:name']==\"start\")\n",
    "        for i in range(1,len(trace_edges)):\n",
    "            t = ms(trace[max(0,i-abstraction_history+1):i+1])\n",
    "            if t not in list(system.nodes()):\n",
    "                s = t\n",
    "                continue\n",
    "            if (s,t) not in data:\n",
    "                data[(s,t)] = 1\n",
    "            else:\n",
    "                data[(s,t)] = data[(s,t)]+1\n",
    "            s = t\n",
    "        data[\"y\"] = 1 if \"positive\" in trace_edges else -1\n",
    "        trace_df = trace_df.append(data, ignore_index=True)\n",
    "    trace_df = trace_df.fillna(0)\n",
    "    assert(len(trace_df.index) == len(log))\n",
    "    return trace_df\n",
    "\n",
    "# analyse used process model with mutli-set abstraction and history 5\n",
    "trace_df = to_df(list_log_application,\"cli/DECB_input:bpi2012_type:multiset_history:5_actors:activities2012_unrolling_factor:0_.gexf\" ,5)\n",
    "trace_df_reduced = to_df(list_log_application,\"cli/DECB_input:bpi2012_type:multiset_history:5_actors:activities2012_unrolling_factor:0_reduced:True.gexf\" ,5)\n",
    "correlations = trace_df.corr().unstack().to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remaining correlations in % after reduction [0.0, nan, nan, 0.0, nan, 0.0, 0.5, 0.24, nan, nan, nan, nan, 0.38981173864894797, 0.32469775474956825, 0.3145631067961165, 0.340625, 0.45045045045045046, 0.2745762711864407, 0.5148514851485149, 0.2714535901926445]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_21340/1143302856.py:6: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  print(\"Remaining correlations in % after reduction\", [counts1[i]/counts[i] for i in range(len(counts))])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# construct comparison plot\n",
    "counts, bins, bars = plt.hist([x for x in trace_df.corr().unstack() if abs(x) > 0.2], 20, label = \"Original\", color = '#0C7BDC')\n",
    "\n",
    "counts1, bins1, bars1 = plt.hist([x for x in trace_df_reduced.corr().unstack() if abs(x) > 0.2], 20, label = \"Reduced\", color = '#FFC20A', range = [-1,1])\n",
    "\n",
    "print(\"Remaining correlations in % after reduction\", [counts1[i]/counts[i] for i in range(len(counts))])\n",
    "\n",
    "plt.xlabel(\"Pearson Correlation\", fontsize = 18)\n",
    "plt.ylabel(\"Occurrences\", fontsize = 18)\n",
    "plt.xticks(fontsize=14)\n",
    "plt.yticks(fontsize=14)\n",
    "plt.legend(prop={'size':14})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit",
   "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.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}