bpi2019_experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from numpy import savetxt\n",
    "from tqdm import tqdm, tqdm_notebook\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "pd.set_option('display.max_columns', None)\n",
    "import sys\n",
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import econml\n",
    "import warnings\n",
    "#warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Main imports\n",
    "from econml.ortho_forest import DMLOrthoForest, DROrthoForest, DiscreteTreatmentOrthoForest\n",
    "from econml.sklearn_extensions.linear_model import WeightedLassoCVWrapper, WeightedLasso, WeightedLassoCV\n",
    "\n",
    "from econml.cate_interpreter import SingleTreeCateInterpreter, SingleTreePolicyInterpreter\n",
    "import graphviz\n",
    "\n",
    "# Helper imports\n",
    "import numpy as np\n",
    "from itertools import product\n",
    "from sklearn.linear_model import Lasso, LassoCV, LogisticRegression, LogisticRegressionCV\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "# A few more imports\n",
    "import os\n",
    "import pandas as pd\n",
    "import urllib.request\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.linear_model import Lasso, LassoCV, LinearRegression, Ridge, ElasticNet\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "case_id_col = \"Case ID\"\n",
    "activity_col = \"Activity\"\n",
    "resource_col = \"org:resource\"\n",
    "timestamp_col = \"time:timestamp\"\n",
    "\n",
    "treatment = 'treatment'\n",
    "outcome = 'duration'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dynamic_cat_cols = ['Activity', 'org:resource']\n",
    "static_cat_cols = ['(case)_Item_Type', '(case)_Spend_area_text', '(case)_Sub_spend_area_text', '(case)_Vendor',\n",
    "                   '(case)_GR-Based_Inv__Verif_', '(case)_Spend_classification_text', '(case)_Item_Category', '(case)_Company',\n",
    "                   '(case)_Name', '(case)_Document_Type']\n",
    "dynamic_num_cols = ['Cumulative_net_worth_(EUR)', 'open_cases', 'month', 'weekday', 'hour', 'timesincelastevent', 'timesincecasestart']\n",
    "static_num_cols = ['timesincefirstcase', '(case)_Item', 'duration', 'treatment']\n",
    "\n",
    "cat_cols = dynamic_cat_cols + static_cat_cols\n",
    "num_cols = dynamic_num_cols + static_num_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tqdm.pandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 =pd.read_csv('data_bpic19_readyToUse.csv')\n",
    "df2['treatment'] = df2[treatment].replace({0:1, 1:0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define some parameters\n",
    "N_trees = [200]\n",
    "Min_leaf_size = [10]\n",
    "Max_depth = [10]\n",
    "Subsample_ratio = [0.7]\n",
    "Lambda_reg= [0.01]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# preparing the data \n",
    "train, valid = train_test_split(df2, test_size=0.2, shuffle=False)\n",
    "train, test = train_test_split(train, test_size=0.2, shuffle=False)\n",
    "features = train.drop([outcome, treatment], axis=1)\n",
    "features_test = test.drop([outcome, treatment], axis=1)\n",
    "\n",
    "\n",
    "cat_confound_cols = ['(case)_Item_Type',  '(case)_Spend_area_text', '(case)_Sub_spend_area_text',\n",
    "                     '(case)_Vendor', '(case)_GR-Based_Inv__Verif_', '(case)_Spend_classification_text',\n",
    "                     '(case)_Item_Category','(case)_Name', '(case)_Company', '(case)_Document_Type', '(case)_Item']\n",
    "num_confound_cols = features.columns.difference(cat_confound_cols)\n",
    "\n",
    "\n",
    "cat_hetero_cols = ['(case)_Item_Type', '(case)_Spend_area_text', '(case)_Sub_spend_area_text',\n",
    "                   '(case)_Vendor', '(case)_GR-Based_Inv__Verif_', '(case)_Spend_classification_text',\n",
    "                   '(case)_Item_Category', '(case)_Name', '(case)_Company', '(case)_Document_Type', '(case)_Item']\n",
    "num_hetero_cols = features.columns.difference(cat_hetero_cols)\n",
    "#num_hetero_cols = ['Cumulative_net_worth_(EUR)']\n",
    "\n",
    "Y = train[outcome].to_numpy()\n",
    "T = train[treatment].to_numpy()\n",
    "scaler = StandardScaler()\n",
    "W1 = scaler.fit_transform(features[[c for c in num_confound_cols]].to_numpy())\n",
    "W2 = pd.get_dummies(features[cat_confound_cols]).to_numpy()\n",
    "W = np.concatenate([W1, W2], axis=1)\n",
    "X1 = scaler.fit_transform(features[[c for c in num_hetero_cols]].to_numpy())\n",
    "X2 = pd.get_dummies(features[cat_hetero_cols]).to_numpy()\n",
    "X = np.concatenate([X1, X2], axis=1)\n",
    "\n",
    "X1_test = scaler.fit_transform(features_test[[c for c in num_hetero_cols]].to_numpy())\n",
    "X2_test = pd.get_dummies(features_test[cat_hetero_cols]).to_numpy()\n",
    "X_test = np.concatenate([X1_test, X2_test], axis=1)\n",
    "\n",
    "tmp = pd.DataFrame(X)\n",
    "tmp2 = pd.DataFrame(X_test)\n",
    "\n",
    "# Get missing columns in the training test\n",
    "missing_cols = set( tmp.columns ) - set( tmp2.columns )\n",
    "# Add a missing column in test set with default value equal to 0\n",
    "for c in missing_cols:\n",
    "    tmp2[c] = 0\n",
    "# Ensure the order of column in the test set is in the same order than in train set\n",
    "tmp2 = tmp2[tmp.columns]\n",
    "\n",
    "X_test = tmp2.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(200, 10, 10, 0.7, 0.01)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The econml.ortho_forest.DMLOrthoForest class has been moved to econml.orf.DMLOrthoForest; an upcoming release will remove support for the old name\n",
      "X and W should be passed by keyword only. In a future release we will disallow passing X and W by position.\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:   28.4s\n",
      "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed:  1.1min finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  64 tasks      | elapsed:   22.0s\n",
      "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed:   58.3s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  76 out of 104 | elapsed:   21.6s remaining:    8.0s\n",
      "[Parallel(n_jobs=-1)]: Done 104 out of 104 | elapsed:   24.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  76 out of 104 | elapsed:   14.6s remaining:    5.4s\n",
      "[Parallel(n_jobs=-1)]: Done 104 out of 104 | elapsed:   17.5s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  76 out of 104 | elapsed:   16.0s remaining:    5.9s\n",
      "[Parallel(n_jobs=-1)]: Done 104 out of 104 | elapsed:   19.1s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  76 out of 104 | elapsed:   16.3s remaining:    6.0s\n",
      "[Parallel(n_jobs=-1)]: Done 104 out of 104 | elapsed:   19.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   14.6s remaining:    5.4s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   18.4s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   16.6s remaining:    6.2s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   15.0s remaining:    5.6s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   18.5s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   16.3s remaining:    6.1s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   19.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.1s remaining:    6.4s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.8s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   16.5s remaining:    6.1s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.3s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.0s remaining:    6.3s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.4s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   15.6s remaining:    5.8s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   19.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   16.3s remaining:    6.1s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.0s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   16.3s remaining:    6.1s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   19.4s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   18.0s remaining:    6.7s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   21.6s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.6s remaining:    6.6s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   21.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   16.8s remaining:    6.3s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.3s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.7s remaining:    6.6s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   22.3s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.4s remaining:    6.5s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   20.8s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   18.2s remaining:    6.8s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   22.4s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.7s remaining:    6.6s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   21.2s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.9s remaining:    6.7s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   21.7s finished\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 32 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  75 out of 103 | elapsed:   17.8s remaining:    6.6s\n",
      "[Parallel(n_jobs=-1)]: Done 103 out of 103 | elapsed:   22.2s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# curve for the test set\n",
    "for i in itertools.product(N_trees, Min_leaf_size, Max_depth, Subsample_ratio, Lambda_reg):\n",
    "    print(i)\n",
    "    n_trees = i[0]\n",
    "    min_leaf_size = i[1]\n",
    "    max_depth = i[2]\n",
    "    subsample_ratio = i[3]\n",
    "    lambda_reg = i[4]\n",
    "    est = DMLOrthoForest(\n",
    "        n_trees=n_trees, min_leaf_size=min_leaf_size, max_depth=max_depth, \n",
    "        subsample_ratio=subsample_ratio, discrete_treatment=True,\n",
    "        model_T=LogisticRegression(C=1/(X.shape[0]*lambda_reg), penalty='l1', solver='saga'),\n",
    "        model_Y=Lasso(alpha=lambda_reg),\n",
    "        model_T_final=LogisticRegression(C=1/(X.shape[0]*lambda_reg), penalty='l1', solver='saga'), \n",
    "        model_Y_final=WeightedLasso(alpha=lambda_reg),\n",
    "        random_state=200\n",
    "       )\n",
    "    \n",
    "    ortho_model = est.fit(Y, T, X, W)\n",
    "    batches = np.array_split(X_test, X_test.shape[0] / 100)\n",
    "    treatment_effects = est.const_marginal_effect(batches[0])\n",
    "    ii = 0\n",
    "    for batch in batches[1:]:\n",
    "#         print(ii)\n",
    "        estimates = est.const_marginal_effect(batch)\n",
    "        treatment_effects = np.append(treatment_effects, estimates)\n",
    "        ii += 1\n",
    "    df_results = test\n",
    "    df_results['Treatment Effects'] = treatment_effects\n",
    "    \n",
    "#     Calculate default (90%) confidence intervals for the default treatment points T0=0 and T1=1\n",
    "#     te_lower, te_upper = est.effect_interval(batches[0])\n",
    "#     ii = 0\n",
    "#     for batch in batches[1:]:\n",
    "#         print(ii)\n",
    "#         lower, upper = est.effect_interval(batch)\n",
    "#         te_lower = np.append(te_lower, lower)\n",
    "#         te_upper = np.append(te_upper, upper)\n",
    "#         ii += 1\n",
    "        \n",
    "#     df_results['te_lower'] = te_lower\n",
    "#     df_results['te_upper'] = te_upper\n",
    "#     df_results['Interval Length'] = df_results['te_upper'] - df_results['te_lower']\n",
    "    \n",
    "    net_value = [0]\n",
    "    net_value2 = [0]\n",
    "    net_value3 = [0]\n",
    "\n",
    "    percentages = [10,20,30,40,50,60,70,80,90,100]\n",
    "\n",
    "    for n in percentages:\n",
    "        num = int(len(df_results)*(n/100))\n",
    "        top_n = df_results.nsmallest(num,'Treatment Effects')\n",
    "        n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "        n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "        scale_factor = n_treated/n_control\n",
    "\n",
    "        treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "        control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "        reduction = (scale_factor*control) - treated \n",
    "        net_value.append(reduction)\n",
    "        \n",
    "#     for n in percentages:\n",
    "#         num = int(len(df_results)*(n/100))\n",
    "#         top_n = df_results.nsmallest(num,'te_lower')\n",
    "#         n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "#         n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "#         scale_factor = n_treated/n_control\n",
    "\n",
    "#         treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "#         control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "#         reduction = (scale_factor*control) - treated \n",
    "#         net_value2.append(reduction)\n",
    "        \n",
    "#     for n in percentages:\n",
    "#         num = int(len(df_results)*(n/100))\n",
    "#         top_n = df_results.nsmallest(num,'te_upper')\n",
    "#         n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "#         n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "#         scale_factor = n_treated/n_control\n",
    "\n",
    "#         treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "#         control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "#         reduction = (scale_factor*control) - treated \n",
    "#         net_value3.append(reduction)\n",
    "\n",
    "    plt.plot([0]+percentages, net_value, label=\"Treatment Effect\", marker=\"o\")\n",
    "#     plt.plot([0]+percentages, net_value2, label=\"TE Lower bound\", marker=\"o\", color='Green')\n",
    "#     plt.plot([0]+percentages, net_value3, label=\"TE Upper bound\", marker=\"o\", color='Red')\n",
    "    plt.plot([0,percentages[9]], [0,net_value[10]], label=\"Random\",  marker=\"o\", color='Black',\n",
    "             linestyle='dashed')\n",
    "    plt.xlabel('Proportion of cases targeted')\n",
    "    plt.ylabel('Expected incremental reduction')\n",
    "    plt.legend(loc='best')\n",
    "    plt.title(i)\n",
    "\n",
    "    plt.savefig('Results/Qini_curve_BPIC19_%s.png'%str(i), format='png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_results.to_csv('Results/dataframe_with_results_BPIC19', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data prep for running baseline\n",
    "train = train[train[treatment]==0]\n",
    "features = train.drop([outcome, treatment, case_id_col], axis=1)\n",
    "features_test = test.drop([outcome, treatment], axis=1)\n",
    "\n",
    "cat_confound_cols = ['(case)_Item_Type',  '(case)_Spend_area_text', '(case)_Sub_spend_area_text',\n",
    "                     '(case)_Vendor', '(case)_GR-Based_Inv__Verif_', '(case)_Spend_classification_text',\n",
    "                     '(case)_Item_Category','(case)_Name', '(case)_Company', '(case)_Document_Type', '(case)_Item']\n",
    "num_confound_cols = features.columns.difference(cat_confound_cols)\n",
    "\n",
    "\n",
    "cat_hetero_cols = ['(case)_Item_Type', '(case)_Spend_area_text', '(case)_Sub_spend_area_text',\n",
    "                   '(case)_Vendor', '(case)_GR-Based_Inv__Verif_', '(case)_Spend_classification_text',\n",
    "                   '(case)_Item_Category', '(case)_Name', '(case)_Company', '(case)_Document_Type', '(case)_Item']\n",
    "num_hetero_cols = features.columns.difference(cat_hetero_cols)\n",
    "#num_hetero_cols = ['Cumulative_net_worth_(EUR)']\n",
    "\n",
    "Y = train[outcome].to_numpy()\n",
    "T = train[treatment].to_numpy()\n",
    "scaler = StandardScaler()\n",
    "\n",
    "X1 = scaler.fit_transform(features[[c for c in num_hetero_cols]].to_numpy())\n",
    "X2 = pd.get_dummies(features[cat_hetero_cols]).to_numpy()\n",
    "X = np.concatenate([X1, X2], axis=1)\n",
    "\n",
    "X1_test = scaler.fit_transform(features_test[[c for c in num_hetero_cols]].to_numpy())\n",
    "X2_test = pd.get_dummies(features_test[cat_hetero_cols]).to_numpy()\n",
    "X_test = np.concatenate([X1_test, X2_test], axis=1)\n",
    "\n",
    "tmp = pd.DataFrame(X)\n",
    "tmp2 = pd.DataFrame(X_test)\n",
    "\n",
    "# Get missing columns in the training test\n",
    "missing_cols = set( tmp.columns ) - set( tmp2.columns )\n",
    "# Add a missing column in test set with default value equal to 0\n",
    "for c in missing_cols:\n",
    "    tmp2[c] = 0\n",
    "# Ensure the order of column in the test set is in the same order than in train set\n",
    "tmp2 = tmp2[tmp.columns]\n",
    "\n",
    "X_test = tmp2.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE of test: 129.88478421413103\n",
      "MAE of test: 124.23359304014299\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "percentages = [10,20,30,40,50,60,70,80,90,100]\n",
    "\n",
    "pred = Lasso()\n",
    "pred.fit(X,Y)\n",
    "\n",
    "pred2 = RandomForestRegressor()\n",
    "pred2.fit(X,Y)\n",
    "\n",
    "yhat_test = pred.predict(X_test)\n",
    "print('MAE of test:', mean_absolute_error(test[outcome], yhat_test))\n",
    "df_results['predictions_lasso'] = yhat_test\n",
    "\n",
    "yhat_test2 = pred2.predict(X_test)\n",
    "print('MAE of test:', mean_absolute_error(test[outcome], yhat_test2))\n",
    "df_results['predictions_RF'] = yhat_test2\n",
    "\n",
    "net_value = [0]\n",
    "net_value2 = [0]\n",
    "net_value3 = [0]\n",
    "for n in percentages:\n",
    "    num = int(len(df_results)*(n/100))\n",
    "    top_n = df_results.nsmallest(num,'Treatment Effects')\n",
    "    n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "    n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "    scale_factor = n_treated/n_control\n",
    "\n",
    "    treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "    control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "    reduction = (scale_factor*control) - treated \n",
    "    net_value.append(reduction)\n",
    "    \n",
    "for n in percentages:\n",
    "    num = int(len(df_results)*(n/100))\n",
    "    top_n = df_results.nsmallest(num,'predictions_lasso')\n",
    "    n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "    n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "    scale_factor = n_treated/n_control\n",
    "\n",
    "    treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "    control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "    reduction = (scale_factor*control) - treated \n",
    "    net_value2.append(reduction)\n",
    "    \n",
    "for n in percentages:\n",
    "    num = int(len(df_results)*(n/100))\n",
    "    top_n = df_results.nsmallest(num,'predictions_RF')\n",
    "    n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "    n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "    scale_factor = n_treated/n_control\n",
    "\n",
    "    treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "    control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "    reduction = (scale_factor*control) - treated \n",
    "    net_value3.append(reduction)\n",
    "#     net_value.append(reduction)\n",
    "\n",
    "#normed = norm = [(float(i)-min(net_value))/(max(net_value)-min(net_value)) for i in net_value]\n",
    "\n",
    "\n",
    "# plt.figure(figsize=(10, 4))\n",
    "# plt.subplot(1, 2, 1)\n",
    "plt.plot([0]+percentages, net_value, label=\"Orthogonal Random Forest\", marker=\"o\")\n",
    "plt.plot([0]+percentages, net_value3, label=\"RandomForestRegressor\", marker=\"o\", color='Red')\n",
    "plt.plot([0]+percentages, net_value2, label=\"Lasso\", marker=\"o\", color='Green')\n",
    "plt.plot([0,percentages[9]], [0,net_value[10]], label=\"Random Policy\",  marker=\"o\", color='Black',\n",
    "         linestyle='dashed')\n",
    "plt.xlabel('Proportion of Cases Targeted')\n",
    "plt.ylabel('Expected Incremental Reduction in Duration')\n",
    "plt.legend(loc='best')\n",
    "plt.title('Qini Curve')\n",
    "\n",
    "plt.savefig('Results/Qini_curve_BPIC19_withBaseline.png', format='png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# net value curves\n",
    "value = [1]\n",
    "cost = [0.3,0.5,1,2,3]\n",
    "\n",
    "percentages = [10,20,30,40,50,60,70,80,90,100]\n",
    "\n",
    "for i in itertools.product(value, cost):\n",
    "    v = i[0]\n",
    "    c = i[1]\n",
    "    net_value = [0]\n",
    "    for n in percentages:\n",
    "        num = int(len(df_results)*(n/100))\n",
    "        top_n = df_results.nsmallest(num,'Treatment Effects')\n",
    "        n_treated = top_n[top_n['treatment']==1].shape[0]\n",
    "        n_control = top_n[top_n['treatment']==0].shape[0]\n",
    "        scale_factor = n_treated/n_control\n",
    "\n",
    "        treated = top_n[top_n['treatment']==1]['duration'].sum()\n",
    "        control = top_n[top_n['treatment']==0]['duration'].sum()\n",
    "\n",
    "        reduction = (scale_factor*control) - treated\n",
    "        net_val = (reduction*v) - (3*n_treated*c)\n",
    "#         print(net_val)\n",
    "        net_value.append(net_val)\n",
    "    #     net_value.append(reduction)\n",
    "\n",
    "    #normed = norm = [(float(i)-min(net_value))/(max(net_value)-min(net_value)) for i in net_value]\n",
    "\n",
    "\n",
    "    # plt.figure(figsize=(10, 4))\n",
    "    # plt.subplot(1, 2, 1)\n",
    "    plt.plot([0]+percentages, net_value, label=\"v/c=%s\"%str(round(v/c,1)), marker=\"o\")\n",
    "    #     plt.plot([0]+percentages, net_value2, label=\"TE Lower bound\", marker=\"o\", color='Green')\n",
    "    #     plt.plot([0]+percentages, net_value3, label=\"TE Upper bound\", marker=\"o\", color='Red')\n",
    "#     plt.plot([0,percentages[9]], [0,net_value[10]], label=\"Random Policy\",  marker=\"o\", color='Black',\n",
    "#              linestyle='dashed')\n",
    "    plt.xlabel('Proportion of Cases Targeted')\n",
    "    plt.ylabel('Expected Net Value')\n",
    "    plt.legend(loc='best')\n",
    "    plt.title('Net-value Curve')\n",
    "\n",
    "plt.savefig('Results/NetVal_curve_BPIC19.png', format='png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 663,
   "position": {
    "height": "40px",
    "left": "1566px",
    "right": "20px",
    "top": "133px",
    "width": "350px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "none",
   "window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}