GAE-GAT-09-Performance-Evaluation3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bcb13bdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "import os.path as osp\n",
    "import copy\n",
    "import os\n",
    "import pickle\n",
    "from datetime import datetime\n",
    "import random\n",
    "from pm4py.objects.conversion.log import converter as log_converter\n",
    "from pm4py.objects.log.exporter.xes import exporter as xes_exporter\n",
    "from pm4py.objects.log.importer.xes import importer as xes_importer\n",
    "from pm4py.algo.filtering.log.attributes import attributes_filter\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn import metrics\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric.data import Dataset, Data\n",
    "from torch_geometric.loader import DataLoader\n",
    "from torch_geometric.nn import NNConv\n",
    "from torch_geometric.nn import GATv2Conv\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ec3d4f93",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nextplot(force=False):\n",
    "    \"\"\"Start a new plot.\n",
    "\n",
    "    In a notebook (or if `force=True`), create a new figure. Otherwise (e.g, in\n",
    "    IPython), clear the current figure.\n",
    "\n",
    "    \"\"\"\n",
    "    inNotebook = \"IPKernelApp\" in get_ipython().config\n",
    "    if force or inNotebook:\n",
    "        plt.figure()  # this creates a new plot\n",
    "    else:\n",
    "        plt.clf()  # and this clears the current one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "409257dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SkinbaronDataset(Dataset):\n",
    "    def __init__(self, root, transform=None, pre_transform=None, pre_filter=None):\n",
    "        super(SkinbaronDataset, self).__init__(root, transform, pre_transform, pre_filter)\n",
    "    @property\n",
    "    def processed_file_names(self):\n",
    "        return processed_graphs\n",
    "    def len(self):\n",
    "        return len(self.processed_file_names)\n",
    "    def get(self, idx):\n",
    "        data = torch.load(osp.join(self.processed_dir, f'data_{idx}.pt'))\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a3d6a128",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GATL1withSelf(nn.Module):\n",
    "    \"\"\"Define GATL1withSelf class for the Graph Attention neural network.(GAT)\n",
    "    with one layer, and self loops\"\"\"\n",
    "\n",
    "    def __init__(self, size_in, size_out, edge_size, num_head, tmax, dropout_prob):\n",
    "        super(GATL1withSelf, self).__init__()\n",
    "        self.conv1 = GATv2Conv(in_channels=size_in, out_channels=size_out, heads=num_head, edge_dim=edge_size,\n",
    "                               dropout=dropout_prob, fill_value='mean')\n",
    "        self.readout = nn.Linear(2 * num_head * size_out, tmax - 1)\n",
    "\n",
    "    def forward(self, graph):\n",
    "        graph.x = F.elu(self.conv1(graph.x, graph.edge_index, graph.edge_attr))\n",
    "        s_t_nodes = torch.cat((graph.x[int(graph.edge_index[0, 0])], graph.x[int(graph.edge_index[1, 0])]))\n",
    "        m_array_pred = torch.sigmoid(self.readout(s_t_nodes))\n",
    "        for i in range(1, graph.edge_index.shape[1]):  # iterate over the number of edges in the batch (called graph)\n",
    "            s_t_nodes = torch.cat((graph.x[int(graph.edge_index[0, i])], graph.x[int(graph.edge_index[1, i])]))\n",
    "            edge_label_pred = torch.sigmoid(self.readout(s_t_nodes))\n",
    "            m_array_pred = torch.cat((m_array_pred, edge_label_pred), 0)\n",
    "        m_array_pred = m_array_pred.view(-1, tmax - 1)\n",
    "        return m_array_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0ea1240d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getListofallkeys(dict):      \n",
    "    return list(dict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eb9cf096",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get meta date from the event log\n",
    "def logStatistics (event_log, main_label):\n",
    "    # set required variables\n",
    "    categorical_value_list = []\n",
    "    cardinality_list = []\n",
    "    cat_encoder_list = []\n",
    "    max_len = 0\n",
    "    # get length of the longest case in the log\n",
    "    num_cases = len(event_log)\n",
    "    for i in range (num_cases):\n",
    "        current_length = len(event_log[i])\n",
    "        max_len = max(max_len, current_length)\n",
    "    # get list of all categorical attributes in the log    \n",
    "    categorical_attributes = list(event_log[0][0].keys())    \n",
    "    categorical_attributes.remove('case_id')\n",
    "    # move the main label to the beginning of the list, if it is not already there.\n",
    "    if categorical_attributes[0] != main_label:\n",
    "        categorical_attributes.insert(0, categorical_attributes.pop(categorical_attributes.index(main_label)))      \n",
    "    # get list of all possible values for main label in the log\n",
    "    main_dict = attributes_filter.get_attribute_values(event_log, categorical_attributes[0])\n",
    "    main_values = list(main_dict.keys())\n",
    "    # one-hot encoding for main category labels\n",
    "    main_array = np.array(main_values)\n",
    "    main_enc = OneHotEncoder(handle_unknown='ignore')\n",
    "    main_enc.fit(main_array.reshape(-1, 1))\n",
    "    # remove the first element (aka main label) from the list\n",
    "    categorical_attributes.pop(0)\n",
    "    # get list of values, and cardinality of each of categorical attributes.\n",
    "    for category in categorical_attributes:\n",
    "        current_cat_dict = attributes_filter.get_attribute_values(event_log, category)\n",
    "        current_cat_list = list(current_cat_dict.keys())\n",
    "        categorical_value_list.append(current_cat_list)\n",
    "        cardinality_list.append(len(current_cat_list))\n",
    "        # one-hot encoding for each of categorical attribute\n",
    "        current_array = np.array(current_cat_list)\n",
    "        current_enc = OneHotEncoder(handle_unknown='ignore')\n",
    "        current_enc.fit(current_array.reshape(-1, 1))\n",
    "        cat_encoder_list.append(current_enc)\n",
    "    return num_cases, max_len, main_array, main_enc, categorical_attributes, cardinality_list, cat_encoder_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "28a290bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# method for creating node feature matrix for one trace, additionally we create a m_array dict, and pair_dict!\n",
    "def build_node_feature_matrix(current_trace, main_label_array, main_encoder, max_trace_length, main_label):\n",
    "    # Compute length of trace\n",
    "    trace_length = len(current_trace)\n",
    "    # dimensions of one-hot encoder for the main label:a dim*dim array:\n",
    "    dim = len(main_label_array)\n",
    "    \"\"\" initialize a dictionary to collect:\n",
    "        Keys: tuple of main category labels (directly-followed pairs) \n",
    "        values: position of pair's occurrence in the trace\n",
    "    \"\"\"\n",
    "    pair_dict = {}\n",
    "    # initialize an auxiliary list to collect to collect unique activity labels in the current case\n",
    "    main_list = []\n",
    "    \"\"\" initialize a dictionary to collect:\n",
    "        Keys: tuple of source node index, and target node index\n",
    "        values: relevant m-array\n",
    "    \"\"\"\n",
    "    m_array_dict = {}\n",
    "    # creating pair_dict dictionary\n",
    "    for i in range(trace_length - 1):\n",
    "        current_main_label = current_trace[i].get(main_label)\n",
    "        main_list.append(current_main_label)\n",
    "        next_main_label = current_trace[i + 1].get(main_label)\n",
    "        main_list.append(next_main_label)\n",
    "        main_tuple = (current_main_label, next_main_label)\n",
    "        if main_tuple in pair_dict:\n",
    "            pair_dict[main_tuple].append(i)\n",
    "        else:\n",
    "            pair_dict[main_tuple] = [i]\n",
    "    # identify unique activity labels, and initialize node feature matrix based on its size.\n",
    "    main_set = list(set(main_list))\n",
    "    node_feature = np.zeros((len(main_set), dim), dtype=np.float32)\n",
    "    # create node feature matrix based on one-hot encoding\n",
    "    counter_main = 0\n",
    "    for main in main_set:\n",
    "        main_arr = np.array(main)\n",
    "        node_feature[counter_main] = main_encoder.transform(main_arr.reshape(-1, 1)).toarray()\n",
    "        counter_main += 1\n",
    "    # iterate over all directly-followed pairs, identify their source and target index in the node set.\n",
    "    # create m-array based on the position(s) of their occurrence, and return indexes, and array in a dictionary\n",
    "    for key in pair_dict:\n",
    "        source_index = main_set.index(key[0])\n",
    "        target_index = main_set.index(key[1])\n",
    "        m_array = np.zeros(max_trace_length - 1, dtype=np.intc)\n",
    "        for i in range(len(pair_dict[key])):\n",
    "            m_array[pair_dict[key][i]] = 1\n",
    "        m_array_dict[(source_index, target_index)] = m_array\n",
    "    return pair_dict, node_feature, m_array_dict, main_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6637827a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# method for creating p_array dict, its structure is similar to the structure of m_array dict!\n",
    "def build_p_array_dict(current_trace, m_array, pairs, main_set, max_trace_length, categorical, cardinality, cat_encoder_list):\n",
    "    p_array_dict = {}\n",
    "    m_size = sum(cardinality) # no need for extra dimension for timestamp as well as binary, numerical, ordinal atts\n",
    "    for key in m_array:\n",
    "        p_array = np.zeros((max_trace_length - 1) * m_size, dtype=np.float32) # seven for case attributes\n",
    "        source_index = key[0]\n",
    "        target_index = key[1]\n",
    "        source_main = main_set[source_index]\n",
    "        target_main = main_set[target_index]\n",
    "        main_tuple = (source_main, target_main)\n",
    "        current_occurrence = pairs[main_tuple]  # is a list\n",
    "        for i in current_occurrence:\n",
    "            # get the changes for categorical attributes\n",
    "            pointer = 0\n",
    "            iterator = 0\n",
    "            for j in categorical:\n",
    "                curr_card = cardinality[iterator]\n",
    "                source_att = current_trace[i].get(j)\n",
    "                target_att = current_trace[i + 1].get(j)\n",
    "                if str(target_att) != 'nan':\n",
    "                    curr_arr = np.array(target_att)\n",
    "                    target_onehot = cat_encoder_list[iterator].transform(curr_arr.reshape(-1, 1)).toarray()\n",
    "                    if str(source_att) == 'nan':\n",
    "                        p_array[i * m_size + pointer: i * m_size + pointer + curr_card] = target_onehot\n",
    "                    else:\n",
    "                        if target_att != source_att:\n",
    "                            curr_arr2 = np.array(source_att)\n",
    "                            source_onehot = cat_encoder_list[iterator].transform(curr_arr2.reshape(-1, 1)).toarray()\n",
    "                            p_array[i * m_size + pointer: i * m_size + pointer + curr_card] = target_onehot - source_onehot\n",
    "                iterator = iterator + 1\n",
    "                pointer = pointer + curr_card\n",
    "                # now that we have the value (p_array), we link it to the current key in our dictionary\n",
    "        p_array_dict[key] = p_array\n",
    "    return p_array_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "47cb8a4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get all categorical attributes in an log + activity label (concept:name) \n",
    "def getcategorical(event_log):\n",
    "    # get list of all categorical attributes in the log    \n",
    "    categorical_attributes = list(event_log[0][0].keys())    \n",
    "    categorical_attributes.remove('case_id')    \n",
    "    return categorical_attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "422a0f71",
   "metadata": {},
   "outputs": [],
   "source": [
    "interest_path = r'D:\\Final master thesis evaluation\\exp3'\n",
    "log_pattern = r'D:\\Final master thesis evaluation\\exp3\\*.xes'\n",
    "processed_path = [r'D:\\Final master thesis evaluation\\exp3\\data\\processed', \n",
    "                  r'D:\\Final master thesis evaluation\\exp4\\data\\processed',\n",
    "                  r'D:\\Final master thesis evaluation\\exp5\\data\\processed',\n",
    "                  r'D:\\Final master thesis evaluation\\exp6\\data\\processed']         \n",
    "processed_Pattern = [r\"D:\\Final master thesis evaluation\\exp3\\data\\processed\\*.pt\",\n",
    "                     r\"D:\\Final master thesis evaluation\\exp4\\data\\processed\\*.pt\",\n",
    "                     r\"D:\\Final master thesis evaluation\\exp5\\data\\processed\\*.pt\",\n",
    "                     r\"D:\\Final master thesis evaluation\\exp6\\data\\processed\\*.pt\"]\n",
    "targat_path = [r\"D:\\Final master thesis evaluation\\exp3\\data\", \n",
    "               r\"D:\\Final master thesis evaluation\\exp4\\data\",\n",
    "               r\"D:\\Final master thesis evaluation\\exp5\\data\",\n",
    "               r\"D:\\Final master thesis evaluation\\exp6\\data\"]\n",
    "logs = glob.glob(log_pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f7ec5dad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "large-1-1\n"
     ]
    }
   ],
   "source": [
    "for log in logs:\n",
    "    name_hint = os.path.basename(log)\n",
    "    name_hint = name_hint.replace('0.', '')\n",
    "    name_hint = name_hint.replace('.xes', '')\n",
    "print(name_hint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9c471df6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9c8f763c6cb946f9853c33ffd2ee6347",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "parsing log, completed traces ::   0%|          | 0/15000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import the log\n",
    "event_log = xes_importer.apply(logs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "eebb4fe1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['user', 'day', 'country', 'company']\n"
     ]
    }
   ],
   "source": [
    "all_attributes = getcategorical (event_log)\n",
    "# remove the first element (aka main label) from the list\n",
    "all_attributes.pop(0)\n",
    "print(all_attributes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "24736c44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:\\Final master thesis evaluation\\exp3\\case_id_list.pkl\n",
      "D:\\Final master thesis evaluation\\exp4\\case_id_list.pkl\n",
      "D:\\Final master thesis evaluation\\exp5\\case_id_list.pkl\n",
      "D:\\Final master thesis evaluation\\exp6\\case_id_list.pkl\n"
     ]
    }
   ],
   "source": [
    "category_counter = 0\n",
    "for category in all_attributes:\n",
    "    if category_counter == 0:\n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp3\\case_id_list.pkl\"\n",
    "    elif category_counter == 1:\n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp4\\case_id_list.pkl\"\n",
    "    elif category_counter == 2: \n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp5\\case_id_list.pkl\"\n",
    "    elif category_counter == 3: \n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp6\\case_id_list.pkl\"\n",
    "    # get required meta data\n",
    "    num_cases, tmax, main_array, main_encoder, categorical_attributes, cardinality_list, cat_encoder_list = logStatistics(event_log, category)\n",
    "    # core part of feature eng.\n",
    "    case_id_list = []\n",
    "    idx = 0\n",
    "    for i in range (len(event_log)):\n",
    "        case = event_log [i]\n",
    "        pairs, node_feature_matrix, m_array_dict, main_set = build_node_feature_matrix(case, main_array, main_encoder, tmax, category)\n",
    "        p_array_dict = build_p_array_dict(case, m_array_dict, pairs, main_set, tmax, categorical_attributes,\n",
    "                                          cardinality_list, cat_encoder_list)\n",
    "        case_id_list.append(case.attributes.get('concept:name'))\n",
    "        edge_index_list = []\n",
    "        edge_att_list = []\n",
    "        edge_marray_list = []\n",
    "        for key in p_array_dict:\n",
    "            edge_index_list.append(list(key))\n",
    "            edge_att_list.append(list(p_array_dict.get(key)))\n",
    "            edge_marray_list.append(list(m_array_dict.get(key)))\n",
    "        edge_index = torch.tensor(edge_index_list, dtype=torch.long)\n",
    "        edge_attr = torch.tensor(edge_att_list, dtype=torch.float)\n",
    "        edge_m_array = torch.tensor(edge_marray_list, dtype=torch.uint8)               \n",
    "        x = torch.from_numpy(node_feature_matrix).float()\n",
    "        graph = Data(x=x, edge_index=edge_index.t().contiguous(), edge_attr=edge_attr, edge_m_array=edge_m_array)\n",
    "        torch.save(graph, osp.join(processed_path[category_counter], f'data_{idx}.pt'))\n",
    "        idx += 1\n",
    "    print(case_id_target)\n",
    "    case_id_file = open(case_id_target, \"wb\")\n",
    "    pickle.dump(case_id_list, case_id_file)\n",
    "    case_id_file.close()        \n",
    "    category_counter += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3e871b89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training graphs: 12000\n",
      "Number of test graphs: 3000\n",
      "user 0\n",
      "user 1\n",
      "user 2\n",
      "user 3\n",
      "user 4\n",
      "Number of training graphs: 12000\n",
      "Number of test graphs: 3000\n",
      "day 0\n",
      "day 1\n",
      "day 2\n",
      "day 3\n",
      "day 4\n",
      "Number of training graphs: 12000\n",
      "Number of test graphs: 3000\n",
      "country 0\n",
      "country 1\n",
      "country 2\n",
      "country 3\n",
      "country 4\n",
      "Number of training graphs: 12000\n",
      "Number of test graphs: 3000\n",
      "company 0\n",
      "company 1\n",
      "company 2\n",
      "company 3\n",
      "company 4\n"
     ]
    }
   ],
   "source": [
    "# set the device to GPU or CPU (only if GPU is not available we will use CPU)\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "# the following line should be commented in order to test GPU computations\n",
    "device = 'cpu'\n",
    "# for reproducibility of the result (note: we use SGD for optimization)\n",
    "np.random.seed(0)\n",
    "# Define binary cross entropy loss.\n",
    "batch_loss = nn.BCELoss()\n",
    "#batch_loss = nn.MSELoss() # in case we use sum of time and control-flow in m-array\n",
    "models_target = [r'D:\\Final master thesis evaluation\\exp3\\user_param.pt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp4\\day_param.pt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp5\\country_param.pt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp6\\company_param.pt']\n",
    "loss_df_target = [r'D:\\Final master thesis evaluation\\exp3\\user_loss.pt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp4\\day_loss.pt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp5\\country_loss.pt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp6\\company_loss.pt']\n",
    "models_txt_target = [r'D:\\Final master thesis evaluation\\exp3\\user.txt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp4\\day.txt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp5\\country.txt',\n",
    "                 r'D:\\Final master thesis evaluation\\exp6\\company.txt']\n",
    "\n",
    "category_counter = 0\n",
    "for category in all_attributes:\n",
    "    if category_counter == 0:\n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp3\\case_id_list.pkl\"\n",
    "    elif category_counter == 1:\n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp4\\case_id_list.pkl\"\n",
    "    elif category_counter == 2: \n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp5\\case_id_list.pkl\"\n",
    "    elif category_counter == 3: \n",
    "        case_id_target = r\"D:\\Final master thesis evaluation\\exp6\\case_id_list.pkl\"\n",
    "    # creating dataset\n",
    "    processed_graphs = glob.glob(processed_Pattern[category_counter])\n",
    "    dataset = SkinbaronDataset(root=targat_path)\n",
    "    # train/validation/test split\n",
    "    train_dataset = dataset[0:12000]\n",
    "    test_dataset = dataset[12000:15000]\n",
    "    print(f'Number of training graphs: {len(train_dataset)}')\n",
    "    print(f'Number of test graphs: {len(test_dataset)}')\n",
    "    # Retrieving the case_id list from saved file on the disk:\n",
    "    case_id_file = open(case_id_target, \"rb\")\n",
    "    case_id_list = pickle.load(case_id_file)\n",
    "    case_id_file.close()\n",
    "    # find the length of the longest trace based on the edge_m_array attribute\n",
    "    tmax = int(dataset.get(0).edge_m_array.shape[1]) + 1\n",
    "    dropout_prob = 0.0\n",
    "    num_head = 1\n",
    "    # initialize the model\n",
    "    size_in = dataset.get(0).x.shape[1]\n",
    "    size_out = int(2 * dataset.get(0).x.shape[1] / num_head)\n",
    "    edge_size = dataset.get(0).edge_attr.shape[1]\n",
    "    model = GATL1withSelf(size_in, size_out, edge_size, num_head, tmax, dropout_prob)\n",
    "    # setting the minibatch size\n",
    "    batch_size = 32    \n",
    "    loader = DataLoader(train_dataset, batch_size=batch_size)\n",
    "    # move to GPU (if available)\n",
    "    model = model.to(device)\n",
    "    # inizialize the optimizer\n",
    "    lr = 0.01\n",
    "    weight_decay = 5e-4\n",
    "    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)\n",
    "    with open(models_txt_target[category_counter], \"w\") as GAT2_file:\n",
    "        # Print model's state_dict\n",
    "        print(\"Model's state_dict:\", file=GAT2_file)\n",
    "        for param_tensor in model.state_dict():\n",
    "            print(param_tensor, \"\\t\", model.state_dict()[param_tensor].size(), file=GAT2_file)\n",
    "        # Print optimizer's state_dict\n",
    "        print(\"Optimizer's state_dict:\", file=GAT2_file)\n",
    "        for var_name in optimizer.state_dict():\n",
    "            print(var_name, \"\\t\", optimizer.state_dict()[var_name], file=GAT2_file)\n",
    "        GAT2_file.close()\n",
    "    # training of the model\n",
    "    epochs = 5\n",
    "    train_hist = {}\n",
    "    train_hist['loss'] = []\n",
    "    # Initialize training\n",
    "    for layer in model.children():\n",
    "        if hasattr(layer, 'reset_parameters'):\n",
    "            layer.reset_parameters()\n",
    "    model.train()\n",
    "    # training loop\n",
    "    begin_time = datetime.now()\n",
    "    for epoch in range(epochs):\n",
    "        print(category, epoch)\n",
    "        for idx, data_batch in enumerate(loader):\n",
    "            data_batch = data_batch.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            loss = batch_loss(model.forward(data_batch).float(), data_batch.edge_m_array.float())\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            train_hist['loss'].append(loss.item())\n",
    "            with open(models_txt_target[category_counter], \"a\") as GAT2_file:\n",
    "                print('[Epoch %4d/%4d] [Batch %4d/%4d] Loss: % 2.2e' % (epoch + 1, epochs,idx + 1, len(loader),\n",
    "                                                                        loss.item()), file=GAT2_file)\n",
    "                GAT2_file.close()\n",
    "    finish_time = datetime.now()\n",
    "    with open(models_txt_target[category_counter], \"a\") as GAT2_file:\n",
    "        print('Training time:', file=GAT2_file)\n",
    "        print(finish_time - begin_time, file=GAT2_file)\n",
    "        GAT2_file.close()  \n",
    "    # save and load learned parameters\n",
    "    torch.save(model.state_dict(), models_target[category_counter])\n",
    "    # get the result in a dataframe\n",
    "    batch_size = 1\n",
    "    loader = DataLoader(test_dataset, batch_size=batch_size)\n",
    "    test_id_list = case_id_list[12000:15000]\n",
    "    loss_list = []\n",
    "    begin_time = datetime.now()\n",
    "    for data_batch in loader:\n",
    "        loss = batch_loss(model.forward(data_batch).float(), data_batch.edge_m_array.float())\n",
    "        if loss > 0:\n",
    "            loss_list.append(loss.item())\n",
    "        else:\n",
    "            loss_list.append(0)      \n",
    "    finish_time = datetime.now()    \n",
    "    with open(models_txt_target[category_counter], \"a\") as GAT2_file:\n",
    "        print('Anomaly score computation time for', len(test_dataset), 'cases:', file=GAT2_file)\n",
    "        print(finish_time - begin_time, file=GAT2_file)\n",
    "        GAT2_file.close()\n",
    "    GAT2_dictionary = {'case_id': test_id_list, 'Loss': loss_list}\n",
    "    loss_df = pd.DataFrame(GAT2_dictionary)\n",
    "    loss_df.to_pickle(loss_df_target[category_counter])\n",
    "    category_counter += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4c1e8e3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_scores_path = r'D:\\Final master thesis evaluation\\exp2\\bestgatmodl_test_loss.pt'\n",
    "user_scores_path = r'D:\\Final master thesis evaluation\\exp3\\user_loss.pt'\n",
    "day_scores_path = r'D:\\Final master thesis evaluation\\exp4\\day_loss.pt'\n",
    "country_scores_path = r'D:\\Final master thesis evaluation\\exp5\\country_loss.pt'\n",
    "company_scores_path = r'D:\\Final master thesis evaluation\\exp6\\company_loss.pt'\n",
    "loss_df = pd.read_pickle(anomaly_scores_path)\n",
    "# normalize anomaly scores\n",
    "normalized_loss_df = loss_df.copy()\n",
    "normalized_loss_df['Loss'] = (normalized_loss_df['Loss'] - normalized_loss_df['Loss'].min()) / (normalized_loss_df['Loss'].max() - normalized_loss_df['Loss'].min())\n",
    "# sort the normalized scores\n",
    "sorted_loss = normalized_loss_df.sort_values(by=['Loss'], ascending = False, ignore_index = True)\n",
    "user_df = pd.read_pickle(user_scores_path)\n",
    "# normalize anomaly scores\n",
    "normalized_user_df = user_df.copy()\n",
    "normalized_user_df['Loss'] = (normalized_user_df['Loss'] - normalized_user_df['Loss'].min()) / (normalized_user_df['Loss'].max() - normalized_user_df['Loss'].min())\n",
    "# sort the normalized scores\n",
    "sorted_user = normalized_user_df.sort_values(by=['Loss'], ascending = False, ignore_index = True)\n",
    "day_df = pd.read_pickle(day_scores_path)\n",
    "# normalize anomaly scores\n",
    "normalized_day_df = day_df.copy()\n",
    "normalized_day_df['Loss'] = (normalized_day_df['Loss'] - normalized_day_df['Loss'].min()) / (normalized_day_df['Loss'].max() - normalized_day_df['Loss'].min())\n",
    "# sort the normalized scores\n",
    "sorted_day = normalized_day_df.sort_values(by=['Loss'], ascending = False, ignore_index = True)\n",
    "country_df = pd.read_pickle(country_scores_path)\n",
    "# normalize anomaly scores\n",
    "normalized_country_df = country_df.copy()\n",
    "normalized_country_df['Loss'] = (normalized_country_df['Loss'] - normalized_country_df['Loss'].min()) / (normalized_country_df['Loss'].max() - normalized_country_df['Loss'].min())\n",
    "# sort the normalized scores\n",
    "sorted_country = normalized_country_df.sort_values(by=['Loss'], ascending = False, ignore_index = True)\n",
    "company_df = pd.read_pickle(company_scores_path)\n",
    "# normalize anomaly scores\n",
    "normalized_company_df = company_df.copy()\n",
    "normalized_company_df['Loss'] = (normalized_company_df['Loss'] - normalized_company_df['Loss'].min()) / (normalized_company_df['Loss'].max() - normalized_company_df['Loss'].min())\n",
    "# sort the normalized scores\n",
    "sorted_company = normalized_company_df.sort_values(by=['Loss'], ascending = False, ignore_index = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e9eb9b3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>case_id</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12000</th>\n",
       "      <td>12001</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       case_id   label\n",
       "12000    12001  normal"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the truth label vactor\n",
    "truth_label_path = r'D:\\Final master thesis evaluation\\exp1\\large-0.1-1.csv'\n",
    "label_csv = pd.read_csv(truth_label_path)\n",
    "label_csv.drop(\"Unnamed: 0\", axis=1, inplace=True)\n",
    "label_csv[\"case_id\"] = pd.to_numeric(label_csv[\"case_id\"])\n",
    "label_csv.case_id.astype(str).astype(int)\n",
    "label_csv.label.astype(str)\n",
    "#label_csv.dtypes\n",
    "test_csv =  label_csv.loc[label_csv['case_id'] > 12000]\n",
    "test_csv.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "532daaa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first false positive: 284\n",
      "[370, 0.9973045822102425, 0.8525345622119815, 0.919254658385093, 0.9756561430201598, 0.9996102883865939, 0.9874879692011549, 0.9533713137931239]\n",
      "(370, 1, 2565, 64)\n"
     ]
    }
   ],
   "source": [
    "normalized_loss_df[\"case_id\"] = pd.to_numeric(loss_df[\"case_id\"])\n",
    "result = pd.merge(normalized_loss_df, test_csv, on=[\"case_id\"])\n",
    "sorted_result = result.sort_values(by=['Loss'], ascending = False, ignore_index = True)\n",
    "sorted_list = sorted_result['label'].tolist()\n",
    "predictions = []\n",
    "for j in range (len(sorted_list)):\n",
    "    if sorted_list[j] == 'normal':\n",
    "        predictions.append(0)\n",
    "    else:\n",
    "        predictions.append(1)\n",
    "prediction_array = np.array(predictions)\n",
    "best_score = 0\n",
    "first_fp = True\n",
    "for j in range (len(sorted_list)):\n",
    "    current_alarms = prediction_array[0:j+1]\n",
    "    current_normals = prediction_array[j+1:]\n",
    "    positives = j+1\n",
    "    true_positives = np.sum(current_alarms)\n",
    "    false_positives = positives - true_positives\n",
    "    if first_fp and false_positives > 0:\n",
    "        first_fp = False\n",
    "        print('first false positive:', j)\n",
    "    negatives = 3000 - positives\n",
    "    false_negatives = np.sum(current_normals)\n",
    "    true_negatives = negatives - false_negatives\n",
    "    precision = true_positives/(true_positives+false_positives)\n",
    "    recall = true_positives/(true_positives+false_negatives)\n",
    "    f1_score = 2*precision*recall/(precision+recall)\n",
    "    if f1_score > best_score:\n",
    "        best_score = f1_score\n",
    "        precision_on_normal = true_negatives/(true_negatives+false_negatives)\n",
    "        recall_on_normal = true_negatives/(true_negatives+false_positives)\n",
    "        f1_score_on_normal = 2*precision_on_normal*recall_on_normal/(precision_on_normal+recall_on_normal)\n",
    "        macro_f1_score = (f1_score + f1_score_on_normal)/2\n",
    "        best_cut = [j, precision, recall, f1_score, precision_on_normal, recall_on_normal,\n",
    "                    f1_score_on_normal, macro_f1_score] \n",
    "        best_confusion = (true_positives, false_positives, true_negatives, false_negatives)\n",
    "print(best_cut)\n",
    "print(best_confusion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e0fc0cc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "normalized_user_df.rename(columns={\"Loss\": \"Loss-user\"}, inplace = True)\n",
    "normalized_day_df.rename(columns={\"Loss\": \"Loss-day\"}, inplace = True)\n",
    "normalized_country_df.rename(columns={\"Loss\": \"Loss-country\"}, inplace = True)\n",
    "normalized_company_df.rename(columns={\"Loss\": \"Loss-company\"}, inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a67ebb0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>case_id</th>\n",
       "      <th>Loss</th>\n",
       "      <th>Loss-user</th>\n",
       "      <th>Loss-day</th>\n",
       "      <th>Loss-country</th>\n",
       "      <th>Loss-company</th>\n",
       "      <th>label</th>\n",
       "      <th>anomaly</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12001</td>\n",
       "      <td>0.000067</td>\n",
       "      <td>0.001915</td>\n",
       "      <td>0.004296</td>\n",
       "      <td>0.002408</td>\n",
       "      <td>0.002055</td>\n",
       "      <td>normal</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   case_id      Loss  Loss-user  Loss-day  Loss-country  Loss-company   label  \\\n",
       "0    12001  0.000067   0.001915  0.004296      0.002408      0.002055  normal   \n",
       "\n",
       "   anomaly  \n",
       "0        0  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "normalized_loss_df[\"case_id\"] = pd.to_numeric(normalized_loss_df[\"case_id\"])\n",
    "normalized_user_df[\"case_id\"] = pd.to_numeric(normalized_user_df[\"case_id\"])\n",
    "normalized_day_df[\"case_id\"] = pd.to_numeric(normalized_day_df[\"case_id\"])\n",
    "normalized_country_df[\"case_id\"] = pd.to_numeric(normalized_country_df[\"case_id\"])\n",
    "normalized_company_df[\"case_id\"] = pd.to_numeric(normalized_company_df[\"case_id\"])\n",
    "mid_result1 = pd.merge(normalized_loss_df, normalized_user_df, on=\"case_id\")\n",
    "mid_result2 = pd.merge(mid_result1, normalized_day_df, on=\"case_id\")\n",
    "mid_result3 = pd.merge(mid_result2, normalized_country_df, on=\"case_id\")\n",
    "mid_result4 = pd.merge(mid_result3, normalized_company_df, on=\"case_id\")\n",
    "combined_df = pd.merge(mid_result4, test_csv, on=\"case_id\")\n",
    "combined_df['anomaly'] = np.where(combined_df['label']!= 'normal', 1, 0)\n",
    "combined_df.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a19855c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "nextplot()\n",
    "combined_df.plot.scatter(x='Loss', y='Loss-user', s=20, c=np.where(combined_df['anomaly']==0, 'g', 'r'))\n",
    "plt.savefig(\"main-user\", dpi=1200)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4634464c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "nextplot()\n",
    "combined_df.plot.scatter(x='Loss', y='Loss-day', s=20, c=np.where(combined_df['anomaly']==0, 'g', 'r'))\n",
    "plt.savefig(\"main-day\", dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "44c20820",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "nextplot()\n",
    "combined_df.plot.scatter(x='Loss', y='Loss-country', s=20, c=np.where(combined_df['anomaly']==0, 'g', 'r'))\n",
    "plt.savefig(\"main-country\", dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "652e8811",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "nextplot()\n",
    "combined_df.plot.scatter(x='Loss', y='Loss-company', s=20, c=np.where(combined_df['anomaly']==0, 'g', 'r'))\n",
    "plt.savefig(\"main-company\", dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "46e69300",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2630\n"
     ]
    }
   ],
   "source": [
    "residual_csv=  combined_df.loc[combined_df['Loss'] < 0.0007]\n",
    "print(len(residual_csv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "84943d76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "nextplot()\n",
    "residual_csv.plot.scatter(x='Loss-user', y='Loss-day', s=20, c=np.where(residual_csv['anomaly']==0, 'g', 'r'))\n",
    "plt.savefig(\"main-user-removed\", dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5f3fc46d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": [
    "nextplot()\n",
    "residual_csv.plot.scatter(x='Loss-company', y='Loss-country', s=20, c=np.where(residual_csv['anomaly']==0, 'g', 'r'))\n",
    "plt.savefig(\"main-user-removed2\", dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "60ac0074",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['Loss-user'] = (residual_csv['Loss-user'] - residual_csv['Loss-user'].min()) / (residual_csv['Loss-user'].max() - residual_csv['Loss-user'].min())\n",
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['Loss-day'] = (residual_csv['Loss-day'] - residual_csv['Loss-day'].min()) / (residual_csv['Loss-day'].max() - residual_csv['Loss-day'].min())\n",
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['Loss-country'] = (residual_csv['Loss-country'] - residual_csv['Loss-country'].min()) / (residual_csv['Loss-country'].max() - residual_csv['Loss-country'].min())\n",
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['Loss-company'] = (residual_csv['Loss-company'] - residual_csv['Loss-company'].min()) / (residual_csv['Loss-company'].max() - residual_csv['Loss-company'].min())\n",
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['Loss'] = (residual_csv['Loss'] - residual_csv['Loss'].min()) / (residual_csv['Loss'].max() - residual_csv['Loss'].min())\n",
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:6: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['att_avg'] = (residual_csv['Loss-user'] + residual_csv['Loss-day'] + residual_csv['Loss-country'] + residual_csv['Loss-company'])/4\n",
      "C:\\Users\\ASUS\\AppData\\Local\\Temp/ipykernel_1176/152007652.py:7: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  residual_csv['att_max'] = residual_csv[['Loss-user','Loss-day','Loss-country','Loss-company']].max(axis=1)\n"
     ]
    }
   ],
   "source": [
    "residual_csv['Loss-user'] = (residual_csv['Loss-user'] - residual_csv['Loss-user'].min()) / (residual_csv['Loss-user'].max() - residual_csv['Loss-user'].min())\n",
    "residual_csv['Loss-day'] = (residual_csv['Loss-day'] - residual_csv['Loss-day'].min()) / (residual_csv['Loss-day'].max() - residual_csv['Loss-day'].min())\n",
    "residual_csv['Loss-country'] = (residual_csv['Loss-country'] - residual_csv['Loss-country'].min()) / (residual_csv['Loss-country'].max() - residual_csv['Loss-country'].min())\n",
    "residual_csv['Loss-company'] = (residual_csv['Loss-company'] - residual_csv['Loss-company'].min()) / (residual_csv['Loss-company'].max() - residual_csv['Loss-company'].min())\n",
    "residual_csv['Loss'] = (residual_csv['Loss'] - residual_csv['Loss'].min()) / (residual_csv['Loss'].max() - residual_csv['Loss'].min())\n",
    "residual_csv['att_avg'] = (residual_csv['Loss-user'] + residual_csv['Loss-day'] + residual_csv['Loss-country'] + residual_csv['Loss-company'])/4\n",
    "residual_csv['att_max'] = residual_csv[['Loss-user','Loss-day','Loss-country','Loss-company']].max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b45239c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "9\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>case_id</th>\n",
       "      <th>Loss</th>\n",
       "      <th>Loss-user</th>\n",
       "      <th>Loss-day</th>\n",
       "      <th>Loss-country</th>\n",
       "      <th>Loss-company</th>\n",
       "      <th>label</th>\n",
       "      <th>anomaly</th>\n",
       "      <th>att_avg</th>\n",
       "      <th>att_max</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>171</th>\n",
       "      <td>12172</td>\n",
       "      <td>0.125141</td>\n",
       "      <td>0.278458</td>\n",
       "      <td>0.243896</td>\n",
       "      <td>0.190243</td>\n",
       "      <td>0.396017</td>\n",
       "      <td>{'anomaly': 'Attribute', 'attr': {'attribute':...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.277154</td>\n",
       "      <td>0.396017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>193</th>\n",
       "      <td>12194</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.592092</td>\n",
       "      <td>0.558853</td>\n",
       "      <td>0.386582</td>\n",
       "      <td>0.509334</td>\n",
       "      <td>{'anomaly': 'Early', 'attr': {'shift_from': 9,...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.511715</td>\n",
       "      <td>0.592092</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>281</th>\n",
       "      <td>12282</td>\n",
       "      <td>0.251872</td>\n",
       "      <td>0.519363</td>\n",
       "      <td>0.338422</td>\n",
       "      <td>0.287423</td>\n",
       "      <td>0.352370</td>\n",
       "      <td>{'anomaly': 'Attribute', 'attr': {'attribute':...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.374395</td>\n",
       "      <td>0.519363</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>447</th>\n",
       "      <td>12448</td>\n",
       "      <td>0.242702</td>\n",
       "      <td>0.475820</td>\n",
       "      <td>0.352600</td>\n",
       "      <td>0.388706</td>\n",
       "      <td>0.206056</td>\n",
       "      <td>{'anomaly': 'Early', 'attr': {'shift_from': 3,...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.355796</td>\n",
       "      <td>0.475820</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>760</th>\n",
       "      <td>12761</td>\n",
       "      <td>0.188253</td>\n",
       "      <td>0.418025</td>\n",
       "      <td>0.348338</td>\n",
       "      <td>0.258138</td>\n",
       "      <td>0.479392</td>\n",
       "      <td>{'anomaly': 'Attribute', 'attr': {'attribute':...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.375973</td>\n",
       "      <td>0.479392</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1726</th>\n",
       "      <td>13727</td>\n",
       "      <td>0.545051</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>{'anomaly': 'Attribute', 'attr': {'attribute':...</td>\n",
       "      <td>1</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2206</th>\n",
       "      <td>14207</td>\n",
       "      <td>0.506867</td>\n",
       "      <td>0.355157</td>\n",
       "      <td>0.398146</td>\n",
       "      <td>0.244751</td>\n",
       "      <td>0.330335</td>\n",
       "      <td>{'anomaly': 'Attribute', 'attr': {'attribute':...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.332097</td>\n",
       "      <td>0.398146</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2631</th>\n",
       "      <td>14632</td>\n",
       "      <td>0.557470</td>\n",
       "      <td>0.417615</td>\n",
       "      <td>0.390470</td>\n",
       "      <td>0.197869</td>\n",
       "      <td>0.524538</td>\n",
       "      <td>{'anomaly': 'Late', 'attr': {'shift_from': 0, ...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.382623</td>\n",
       "      <td>0.524538</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2960</th>\n",
       "      <td>14961</td>\n",
       "      <td>0.178486</td>\n",
       "      <td>0.446332</td>\n",
       "      <td>0.299552</td>\n",
       "      <td>0.312105</td>\n",
       "      <td>0.480918</td>\n",
       "      <td>{'anomaly': 'Attribute', 'attr': {'attribute':...</td>\n",
       "      <td>1</td>\n",
       "      <td>0.384726</td>\n",
       "      <td>0.480918</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      case_id      Loss  Loss-user  Loss-day  Loss-country  Loss-company  \\\n",
       "171     12172  0.125141   0.278458  0.243896      0.190243      0.396017   \n",
       "193     12194  1.000000   0.592092  0.558853      0.386582      0.509334   \n",
       "281     12282  0.251872   0.519363  0.338422      0.287423      0.352370   \n",
       "447     12448  0.242702   0.475820  0.352600      0.388706      0.206056   \n",
       "760     12761  0.188253   0.418025  0.348338      0.258138      0.479392   \n",
       "1726    13727  0.545051   1.000000  1.000000      1.000000      1.000000   \n",
       "2206    14207  0.506867   0.355157  0.398146      0.244751      0.330335   \n",
       "2631    14632  0.557470   0.417615  0.390470      0.197869      0.524538   \n",
       "2960    14961  0.178486   0.446332  0.299552      0.312105      0.480918   \n",
       "\n",
       "                                                  label  anomaly   att_avg  \\\n",
       "171   {'anomaly': 'Attribute', 'attr': {'attribute':...        1  0.277154   \n",
       "193   {'anomaly': 'Early', 'attr': {'shift_from': 9,...        1  0.511715   \n",
       "281   {'anomaly': 'Attribute', 'attr': {'attribute':...        1  0.374395   \n",
       "447   {'anomaly': 'Early', 'attr': {'shift_from': 3,...        1  0.355796   \n",
       "760   {'anomaly': 'Attribute', 'attr': {'attribute':...        1  0.375973   \n",
       "1726  {'anomaly': 'Attribute', 'attr': {'attribute':...        1  1.000000   \n",
       "2206  {'anomaly': 'Attribute', 'attr': {'attribute':...        1  0.332097   \n",
       "2631  {'anomaly': 'Late', 'attr': {'shift_from': 0, ...        1  0.382623   \n",
       "2960  {'anomaly': 'Attribute', 'attr': {'attribute':...        1  0.384726   \n",
       "\n",
       "       att_max  \n",
       "171   0.396017  \n",
       "193   0.592092  \n",
       "281   0.519363  \n",
       "447   0.475820  \n",
       "760   0.479392  \n",
       "1726  1.000000  \n",
       "2206  0.398146  \n",
       "2631  0.524538  \n",
       "2960  0.480918  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "guess2 = residual_csv.loc[residual_csv['att_max'] > 0.39]\n",
    "print(len(guess2))\n",
    "print(np.sum(guess2['anomaly']))\n",
    "guess2.head(10)"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}