gen_payoff_group.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8d4ca75d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import os\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import pickle \n",
    "from matplotlib import pyplot as plt\n",
    "from collections import Counter\n",
    "import numpy as np\n",
    "import torch\n",
    "import logging\n",
    "from tqdm import tqdm\n",
    "from datetime import datetime\n",
    "import ast\n",
    "from operator import itemgetter\n",
    "from collections import OrderedDict\n",
    "import random\n",
    "\n",
    "\n",
    "from utils.tree_utils import *\n",
    "from utils.utils import *\n",
    "from dataset import *\n",
    "from model import *\n",
    "import torch\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "import math\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "590c2652",
   "metadata": {},
   "outputs": [],
   "source": [
    "## People\n",
    "## Time\n",
    "## Topic\n",
    "## Media Contents\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "69cd3410",
   "metadata": {},
   "outputs": [],
   "source": [
    "out_dir = '../data'\n",
    "data_dir = '../data'\n",
    "journalist = 'aliceysu'\n",
    "batch_size = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "da562edf",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 419/419 [00:00<00:00, 21122.25it/s]\n",
      "100%|██████████| 419/419 [00:00<00:00, 16379.27it/s]\n"
     ]
    }
   ],
   "source": [
    "### Data (normalize input inter-event times, then padding to create dataloaders)\n",
    "num_classes, num_sequences = 0, 0\n",
    "seq_dataset = []\n",
    "arr = []\n",
    "dp = []\n",
    "rel = []\n",
    "\n",
    "split = [100, 150]\n",
    "# meifongwriter: 100, 150\n",
    "# JiayangFan: 80: 84\n",
    "# muyixiao: 12: 16\n",
    "# lingling: 98, 99\n",
    "# alice: 100, 150\n",
    "val = 0\n",
    "journal_sort = pd.read_csv((os.path.join(data_dir, f'{journalist}/{journalist}_conv_labels.csv')))\n",
    "ids = []\n",
    "for item in list(journal_sort['conversation_id']):\n",
    "    if item not in ids:\n",
    "        ids.append(item)\n",
    "id_pair = {}\n",
    "id_conv = {}\n",
    "for idx in ids:\n",
    "    id_pair[idx], id_conv[idx] = create_conversation_list(journal_sort[journal_sort['conversation_id']==idx], idx)\n",
    "id_data, uid, data, label = create_data(journal_sort, ids)\n",
    "prob = pkl.load(open(os.path.join(data_dir, f'{journalist}/{journalist}_edgeprob.pkl'), 'rb'))\n",
    "\n",
    "with open(os.path.join(data_dir, f'{journalist}/{journalist}_global_path.txt'), \"r\") as f:\n",
    "    for line in tqdm(f, total=get_number_of_lines(f)):\n",
    "        dp.append(json.loads(line.strip()))\n",
    "\n",
    "with open(os.path.join(data_dir, f'{journalist}/{journalist}_local_path.txt'), \"r\") as f:\n",
    "    for line in tqdm(f, total=get_number_of_lines(f)):\n",
    "        rel.append(json.loads(line.strip()))\n",
    "\n",
    "global_input = convert_global(dp, id_data)\n",
    "local_data = convert_local(rel)\n",
    "local_mat = generate_local_mat(local_data, id_data)\n",
    "local_input = create_mat(local_mat, mat_type='concat')\n",
    "logging.info(f'loaded split {journalist}...')\n",
    "num_classes = 3\n",
    "#num_sequences += len(data[split]['arrival_times'])\n",
    "num_sequences = len(set(journal_sort['conversation_id']))\n",
    "\n",
    "id_train, id_dev, id_test = id_data[:split[0]], id_data[split[0]:split[1]], id_data[split[1]:]\n",
    "uid_train, uid_dev, uid_test = uid[:split[0]], uid[split[0]:split[1]], uid[split[1]:]\n",
    "X_train, X_dev, X_test = data[:split[0]], data[split[0]:split[1]], data[split[1]:]\n",
    "prob_train, prob_dev, prob_test = prob[:split[0]], prob[split[0]:split[1]], prob[split[1]:]\n",
    "global_train, global_dev, global_test = global_input[:split[0]], global_input[split[0]:split[1]], global_input[split[1]:]\n",
    "local_train, local_dev, local_test = local_input[:split[0]], local_input[split[0]:split[1]], local_input[split[1]:]\n",
    "label_train, label_dev, label_test = label[:split[0]], label[split[0]:split[1]], label[split[1]:]\n",
    "\n",
    "d_train = TreeDataset(id_train, uid_train, X_train, prob_train, global_train, local_train, label_train)\n",
    "d_val = TreeDataset(id_dev, uid_dev, X_dev, prob_dev, global_dev, local_dev, label_dev)  \n",
    "d_test  = TreeDataset(id_test, uid_test, X_test, prob_test, global_test, local_test, label_test)   \n",
    "\n",
    "# for padding input sequences to maxlen of batch for running on gpu, and arranging them by length efficient\n",
    "collate = collate  \n",
    "train = torch.utils.data.DataLoader(d_train, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "val = torch.utils.data.DataLoader(d_val, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "test = torch.utils.data.DataLoader(d_test, batch_size=batch_size, shuffle=False, collate_fn=collate)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "eb6cb12a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# val\n",
    "with open(os.path.join(out_dir, f'{journalist}/strat_val.pkl'), 'rb') as file:\n",
    "    strat_val = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/true_labels.pkl'), 'rb') as file:\n",
    "    true_labels = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/pred_val.pkl'), 'rb') as file:\n",
    "    pred_val = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/output_val.pkl'), 'rb') as file:\n",
    "    output_val = pickle.load(file)\n",
    "\n",
    "# with open(os.path.join(out_dir, f'{journalist}/predicted.pkl'), 'rb') as file:\n",
    "#     predicted = pickle.load(file)\n",
    "# train\n",
    "with open(os.path.join(out_dir, f'{journalist}/strat_tr.pkl'), 'rb') as file:\n",
    "    strat_train = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/pred_tr.pkl'), 'rb') as file:\n",
    "    pred_train = pickle.load(file)\n",
    "    \n",
    "with open(os.path.join(out_dir, f'{journalist}/output.pkl'), 'rb') as file:\n",
    "    output_train = pickle.load(file)\n",
    "# test\n",
    "with open(os.path.join(out_dir, f'{journalist}/strat_te.pkl'), 'rb') as file:\n",
    "    strat_test = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/pred_te.pkl'), 'rb') as file:\n",
    "    pred_test = pickle.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "4ca02c73",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_te = []\n",
    "for item in pred_test:\n",
    "    for x in item:\n",
    "        pred_te.append(x)\n",
    "\n",
    "label_id = {}\n",
    "for i in range(len(id_test)):\n",
    "    for j in range(len(id_test[i])):\n",
    "        if j >= len(pred_te[i]):\n",
    "            continue\n",
    "        label_id[id_test[i][j]] = pred_te[i][j]\n",
    "for index, row in journal_sort.iterrows():\n",
    "    tid = row['tweet_id']\n",
    "    l = row['labels']\n",
    "    if l ==0 or l == 1 or l == 2:\n",
    "        continue\n",
    "    else:\n",
    "        if tid not in label_id.keys():\n",
    "            journal_sort.loc[index, 'labels'] = random.choice([0,1,2])\n",
    "        else: \n",
    "            journal_sort.loc[index, 'labels'] = label_id[tid]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "ea6901fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "strat_all = []\n",
    "for item in (strat_train + strat_val + strat_test):\n",
    "    for x in item:\n",
    "        strat_all.append(x)\n",
    "\n",
    "strat_id = {}\n",
    "for i in range(len(id_data)):\n",
    "    for j in range(len(id_data[i])):\n",
    "        if j >= len(strat_all[i]):\n",
    "            continue\n",
    "        strat_id[id_data[i][j]] = strat_all[i][j]\n",
    "\n",
    "journal_sort['strategy'] = journal_sort['tweet_id'].map(strat_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "cc9fd57d",
   "metadata": {},
   "outputs": [],
   "source": [
    "date_format = '%Y-%m-%d %H:%M:%S'\n",
    "collect_time = datetime.strptime('2023-01-01 00:00:00', date_format)\n",
    "conv = journal_sort.dropna(subset=['strategy']).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "7a07be7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_attack = conv[conv['labels']==0] \n",
    "conv_by = conv[conv['labels']==1] \n",
    "conv_support = conv[conv['labels']==2] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "a2f680ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_3662180/2670526621.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",
      "  conv_attack['utility_a'] = None\n",
      "/tmp/ipykernel_3662180/2670526621.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",
      "  conv_attack['utility_b'] = None\n",
      "/tmp/ipykernel_3662180/2670526621.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",
      "  conv_attack['utility_c'] = None\n"
     ]
    }
   ],
   "source": [
    "journal = conv_attack['author_id'].iloc[0]\n",
    "conv_attack['utility_a'] = None\n",
    "conv_attack['utility_b'] = None\n",
    "conv_attack['utility_c'] = None\n",
    "strat_id = {}\n",
    "reply_utility_a = []\n",
    "reply_utility_b = []\n",
    "reply_utility_c = []\n",
    "\n",
    "for index, row in conv_attack.iterrows():\n",
    "    tweet_id = row['tweet_id']\n",
    "    time = datetime.strptime(row['created_at'][:19], date_format)\n",
    "    refer = conv[conv['reference_id']==tweet_id]\n",
    "    count_a = row['like_count'] + row['quote_count'] + np.log(row['impression_count']+1) \\\n",
    "                    + row['reply_count'] + row['retweet_count']\n",
    "    if len(refer)==0:\n",
    "        attacked = 0\n",
    "        by_journal = 0\n",
    "    else:\n",
    "        attacked = len(refer[refer['labels']==2]) + len(refer[refer['labels']==1])\n",
    "        by_journal = len(refer[refer['user_id']==journal])\n",
    "        # count_all = attacked + by_journal + row['like_count'] + row['quote_count'] + \\\n",
    "        #             (np.log(row['impression_count']+1)) + row['reply_count'] + row['retweet_count']\n",
    "    delta_time_dirty = (collect_time - time).total_seconds() \n",
    "    delta_time = float(divmod(delta_time_dirty, 3600)[0]) / 480\n",
    "    utility_a = count_a / delta_time\n",
    "    utility_b = attacked / delta_time\n",
    "    utility_c = by_journal / delta_time\n",
    "    conv_attack.loc[index, 'utility_a'] = utility_a\n",
    "    conv_attack.loc[index, 'utility_b'] = utility_b\n",
    "    conv_attack.loc[index, 'utility_c'] = utility_c\n",
    "\n",
    "    reply_utility_a.append([np.argmax(row['strategy']), utility_a])\n",
    "    reply_utility_b.append([np.argmax(row['strategy']), utility_b])\n",
    "    reply_utility_c.append([np.argmax(row['strategy']), utility_c])\n",
    "    if row['user_id'] not in strat_id.keys():\n",
    "        strat_id[row['user_id']] = {'strategy':[row['strategy']], \n",
    "                                    'utility_a':[utility_a],\n",
    "                                    'utility_b':[utility_b],\n",
    "                                    'utility_c':[utility_c]\n",
    "                                    }\n",
    "    else:\n",
    "        strat_id[row['user_id']]['strategy'].append(row['strategy'])\n",
    "        strat_id[row['user_id']]['utility_a'].append(utility_a)\n",
    "        strat_id[row['user_id']]['utility_b'].append(utility_b)\n",
    "        strat_id[row['user_id']]['utility_c'].append(utility_c)\n",
    "\n",
    "user_utility = []\n",
    "for k, v in strat_id.items():\n",
    "    strat = np.argmax(np.mean(strat_id[k]['strategy'], axis=0))\n",
    "    u_a = np.mean(strat_id[k]['utility_a'])\n",
    "    u_b = np.mean(strat_id[k]['utility_b'])\n",
    "    u_c = np.mean(strat_id[k]['utility_c'])\n",
    "    user_utility.append([strat, u_a, u_b, u_c])\n",
    "\n",
    "strategy = {'a':{}, 'b':{}, 'c':{}}\n",
    "for item in user_utility:\n",
    "    if item[0] not in strategy['a'].keys():\n",
    "        strategy['a'][item[0]] = [item[1]]\n",
    "        strategy['b'][item[0]] = [item[2]]\n",
    "        strategy['c'][item[0]] = [item[3]]\n",
    "    else:\n",
    "        strategy['a'][item[0]].append(item[1])\n",
    "        strategy['b'][item[0]].append(item[2])\n",
    "        strategy['c'][item[0]].append(item[3])\n",
    "\n",
    "alice_attack = {'a': OrderedDict(sorted(strategy['a'].items())),\n",
    "                       'b': OrderedDict(sorted(strategy['b'].items())),\n",
    "                       'c': OrderedDict(sorted(strategy['c'].items())),\n",
    "                       }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a8a3e2e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# muyixiao_attack, meifong_attack, jiayangfan_attack, lingling_attack, alice_attack\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "1c39d4a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "strategy = {'a':{}, 'b':{}, 'c':{}}\n",
    "for item in user_utility:\n",
    "    if item[0] not in strategy['a'].keys():\n",
    "        strategy['a'][item[0]] = [item[1]]\n",
    "        strategy['b'][item[0]] = [item[2]]\n",
    "        strategy['c'][item[0]] = [item[3]]\n",
    "    else:\n",
    "        strategy['a'][item[0]].append(item[1])\n",
    "        strategy['b'][item[0]].append(item[2])\n",
    "        strategy['c'][item[0]].append(item[3])\n",
    "\n",
    "alice_attack = {'a': OrderedDict(sorted(strategy['a'].items())),\n",
    "                       'b': OrderedDict(sorted(strategy['b'].items())),\n",
    "                       'c': OrderedDict(sorted(strategy['c'].items())),\n",
    "                       }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 662,
   "id": "b86c376b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#sorted_dict_muyixiao = sorted_dict\n",
    "#sorted_dict_jiayangfan = sorted_dict\n",
    "#sorted_dict_lingling\n",
    "# with open('../result/payoff_muyixiao.pkl', 'wb') as pickle_file:\n",
    "#     pickle.dump(sorted_dict_muyixiao, pickle_file)\n",
    "# with open('../result/payoff_jiayangfan.pkl', 'wb') as pickle_file:\n",
    "#     pickle.dump(sorted_dict_jiayangfan, pickle_file)\n",
    "# with open('../result/payoff_lingling.pkl', 'wb') as pickle_file:\n",
    "#     pickle.dump(sorted_dict_lingling, pickle_file)\n",
    "# with open('../result/payoff_meifong.pkl', 'wb') as pickle_file:\n",
    "#     pickle.dump(sorted_dict_meifong, pickle_file)\n",
    "with open('../result/payoff_alice.pkl', 'wb') as pickle_file:\n",
    "    pickle.dump(sorted_dict_alice, pickle_file)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 665,
   "id": "4fb18f42",
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_all = {}\n",
    "for ind, item in sorted_dict_meifong.items():\n",
    "    sorted_all[ind] = {}\n",
    "    for k, v in item.items():\n",
    "        sorted_all[ind][k] = v + sorted_dict_jiayangfan[ind][k] + sorted_dict_muyixiao[ind][k] + sorted_dict_lingling[ind][k] \n",
    "    # if k in sorted_dict_meifong.keys():\n",
    "    #     sorted_all[k] = sorted_all[k] + sorted_dict_meifong[k]\n",
    "    if k in sorted_dict_alice.keys():\n",
    "        sorted_all[k] = sorted_all[k] + sorted_dict_alice[k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "f1ba8455",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 0.4928131416837782\n",
      "7 29.9229073626389\n",
      "11 44.08163265306122\n",
      "2 28.742514970059883\n",
      "4 1.1446781369205068\n",
      "======\n",
      "7 0.0\n",
      "7 2.0253164556962022\n",
      "11 1.1403899225496306\n",
      "2 0.5748502994011976\n",
      "4 0.9974778332593098\n",
      "======\n",
      "7 0.0\n",
      "7 0.0\n",
      "11 0.0\n",
      "2 0.0\n",
      "4 0.0\n",
      "======\n"
     ]
    }
   ],
   "source": [
    "count = {}\n",
    "for ind, item in sorted_all.items():\n",
    "    count[ind] = 0\n",
    "    for k, v in item.items():\n",
    "        for x in v:\n",
    "            if x > 0.1:\n",
    "                count[ind] += 1\n",
    "        print(len(v), max(v))\n",
    "    print(\"======\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "e2f1d696",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': [0.07040187738339689,\n",
       "  5.606314266135766,\n",
       "  4.660683138189717,\n",
       "  15.080267824764062,\n",
       "  0.7880626208978434],\n",
       " 'b': [0.0,\n",
       "  0.2893309222423146,\n",
       "  0.16718907989831894,\n",
       "  0.2874251497005988,\n",
       "  0.5066233505018432],\n",
       " 'c': [0.0, 0.0, 0.0, 0.0, 0.0]}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean = {}\n",
    "for ind, item in sorted_all.items():\n",
    "    mean[ind] = []\n",
    "    for k, v in item.items():\n",
    "        mean[ind].append(np.mean(v))\n",
    "mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "ca34f98a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': {1: 0.07040187738339689, 2: 5.606314266135766, 3: 4.660683138189717, 5: 15.080267824764062, 7: 0.7880626208978434}, 'b': {1: 0.0, 2: 0.2893309222423146, 3: 0.16718907989831894, 5: 0.2874251497005988, 7: 0.5066233505018432}, 'c': {1: 0.0, 2: 0.0, 3: 0.0, 5: 0.0, 7: 0.0}}\n",
      "0.1935483870967742\n"
     ]
    }
   ],
   "source": [
    "scale = {'a': 1, 'b': 1, 'c': 100}\n",
    "sorted_scale = {'a': {}, 'b': {}, 'c': {}}\n",
    "for ind, item in sorted_all.items():\n",
    "    for k, v in item.items():\n",
    "        sorted_scale[ind][k] = [scale[ind] * x for x in v]\n",
    "\n",
    "mean = {'a': {}, 'b': {}, 'c': {}}\n",
    "for ind, item in sorted_scale.items():\n",
    "    for k, v in item.items():\n",
    "        if ind == 'a':\n",
    "            mean[ind][k] = np.mean(v)\n",
    "        else:\n",
    "            mean[ind][k] = np.mean(v)\n",
    "print(mean)\n",
    "\n",
    "c = 0\n",
    "total_len = 0\n",
    "for k, v in sorted_scale['b'].items():\n",
    "    total_len += len(v)\n",
    "    for item in v:\n",
    "        if item >= 0.5066:\n",
    "            c += 1\n",
    "print(c / total_len)\n",
    "# a: 12.0% 0.7135\n",
    "# b: 10.5% 0.111\n",
    "# c: 2.1% 0.0052"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "27e8d1d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define bins with a width of 0.2 and range up to 4\n",
    "bins = np.arange(0., 1, 0.05)\n",
    "bin_centers = 0.5 * (bins[1:] + bins[:-1])\n",
    "\n",
    "# Calculate histogram for each dataset within the range and convert counts to percentages\n",
    "total_points = {}\n",
    "hist_per = {}\n",
    "for k, v in sorted_all['a'].items():\n",
    "    total_points[k] = len(v)\n",
    "    hist, _ = np.histogram(v, bins=bins)\n",
    "    hist_per[k] = (hist / total_points[k]) * 100\n",
    "\n",
    "\n",
    "\n",
    "# Plotting the histograms as lines on the same figure\n",
    "for k in hist_per.keys():\n",
    "    plt.plot(bin_centers, hist_per[k], linestyle='-', marker='o', mfc='none', label=k, markersize=5)\n",
    "y = range(70)\n",
    "x = [0.7135] * len(y)\n",
    "# Plotting the data\n",
    "#plt.plot(x, y, label='Data Line')\n",
    "plt.plot(x, y, 'y--') \n",
    "plt.xlim([0.01, bins[-1]])  # Adjust x-axis to include the last bin\n",
    "\n",
    "# Remove borders\n",
    "plt.gca().spines['top'].set_visible(False)\n",
    "plt.gca().spines['right'].set_visible(False)\n",
    "plt.gca().spines['bottom'].set_visible(False)\n",
    "plt.gca().spines['left'].set_visible(False)\n",
    "\n",
    "# Remove grids\n",
    "plt.grid(False)\n",
    "\n",
    "# Customize the y-axis to show percentages\n",
    "max_percentage = 70 #max(max(hist_per[i]) for i in range(len(hist_per)))\n",
    "plt.ylim([-0.5, max_percentage + (5 - max_percentage % 5)])  # Adjust ylim for visibility\n",
    "plt.gca().set_yticks(np.arange(0, max_percentage + 1, step=5))\n",
    "plt.gca().set_yticklabels([f'{x:.0f}%' for x in np.arange(0, max_percentage + 1, step=5)])\n",
    "\n",
    "plt.xlabel('Utility Score A')\n",
    "plt.ylabel('Percentage of Users')\n",
    "plt.title('Distribution of Utility')\n",
    "plt.legend()\n",
    "plt.savefig('../result/payoff_a.png')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "478a3a24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define bins with a width of 0.2 and range up to 4\n",
    "bins = np.arange(0., 0.5, 0.05)\n",
    "bin_centers = 0.5 * (bins[1:] + bins[:-1])\n",
    "\n",
    "# Calculate histogram for each dataset within the range and convert counts to percentages\n",
    "total_points = {}\n",
    "hist_per = {}\n",
    "for k, v in sorted_scale['b'].items():\n",
    "    total_points[k] = len(v)\n",
    "    hist, _ = np.histogram(v, bins=bins)\n",
    "    hist_per[k] = (hist / total_points[k]) * 100\n",
    "\n",
    "\n",
    "\n",
    "# Plotting the histograms as lines on the same figure\n",
    "for k in hist_per.keys():\n",
    "    plt.plot(bin_centers, hist_per[k], linestyle='-', marker='o', mfc='none', label=k, markersize=5)\n",
    "y = range(100)\n",
    "x = [0.111] * len(y)\n",
    "# Plotting the data\n",
    "#plt.plot(x, y, label='Data Line')\n",
    "plt.plot(x, y, 'y--') \n",
    "plt.xlim([0.0, bins[-1]])  # Adjust x-axis to include the last bin\n",
    "\n",
    "# Remove borders\n",
    "plt.gca().spines['top'].set_visible(False)\n",
    "plt.gca().spines['right'].set_visible(False)\n",
    "plt.gca().spines['bottom'].set_visible(False)\n",
    "plt.gca().spines['left'].set_visible(False)\n",
    "\n",
    "# Remove grids\n",
    "plt.grid(False)\n",
    "\n",
    "# Customize the y-axis to show percentages\n",
    "max_percentage = 100 #max(max(hist_per[i]) for i in range(len(hist_per)))\n",
    "plt.ylim([-0.5, max_percentage + (5 - max_percentage % 5)])  # Adjust ylim for visibility\n",
    "plt.gca().set_yticks(np.arange(0, max_percentage + 1, step=5))\n",
    "plt.gca().set_yticklabels([f'{x:.0f}%' for x in np.arange(0, max_percentage + 1, step=5)])\n",
    "\n",
    "plt.xlabel('Utility Score B')\n",
    "plt.ylabel('Percentage of Users')\n",
    "plt.title('Distribution of Utility')\n",
    "plt.legend()\n",
    "plt.savefig('../result/payoff_b.png')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "79bb5fbe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define bins with a width of 0.2 and range up to 4\n",
    "bins = np.arange(0., 0.05, 0.005)\n",
    "bin_centers = 0.5 * (bins[1:] + bins[:-1])\n",
    "\n",
    "# Calculate histogram for each dataset within the range and convert counts to percentages\n",
    "total_points = {}\n",
    "hist_per = {}\n",
    "for k, v in sorted_scale['c'].items():\n",
    "    total_points[k] = len(v)\n",
    "    hist, _ = np.histogram(v, bins=bins)\n",
    "    hist_per[k] = (hist / total_points[k]) * 100\n",
    "\n",
    "\n",
    "\n",
    "# Plotting the histograms as lines on the same figure\n",
    "for k in hist_per.keys():\n",
    "    plt.plot(bin_centers, hist_per[k], linestyle='-', marker='o', mfc='none', label=k, markersize=5)\n",
    "y = range(100)\n",
    "x = [0.0052] * len(y)\n",
    "# Plotting the data\n",
    "#plt.plot(x, y, label='Data Line')\n",
    "plt.plot(x, y, 'y--') \n",
    "plt.xlim([0.0, bins[-1]])  # Adjust x-axis to include the last bin\n",
    "\n",
    "# Remove borders\n",
    "plt.gca().spines['top'].set_visible(False)\n",
    "plt.gca().spines['right'].set_visible(False)\n",
    "plt.gca().spines['bottom'].set_visible(False)\n",
    "plt.gca().spines['left'].set_visible(False)\n",
    "\n",
    "# Remove grids\n",
    "plt.grid(False)\n",
    "\n",
    "# Customize the y-axis to show percentages\n",
    "max_percentage = 80 #max(max(hist_per[i]) for i in range(len(hist_per)))\n",
    "plt.ylim([-0.5, max_percentage + (5 - max_percentage % 5)])  # Adjust ylim for visibility\n",
    "plt.gca().set_yticks(np.arange(0, max_percentage + 1, step=5))\n",
    "plt.gca().set_yticklabels([f'{x:.0f}%' for x in np.arange(0, max_percentage + 1, step=5)])\n",
    "\n",
    "plt.xlabel('Utility Score C')\n",
    "plt.ylabel('Percentage of Users')\n",
    "plt.title('Distribution of Utility')\n",
    "plt.legend()\n",
    "plt.savefig('../result/payoff_c.png')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "426ca511",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49a4301c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f6e2bc0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a38795be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36e27822",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4da9439",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import os\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import pickle \n",
    "from matplotlib import pyplot as plt\n",
    "from collections import Counter\n",
    "import numpy as np\n",
    "import torch\n",
    "import logging\n",
    "from tqdm import tqdm\n",
    "import ast\n",
    "from operator import itemgetter\n",
    "\n",
    "\n",
    "from utils.tree_utils import *\n",
    "from utils.utils import *\n",
    "from dataset import *\n",
    "from model import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fef278a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f383a97",
   "metadata": {},
   "outputs": [],
   "source": [
    "out_dir = '../data/'\n",
    "data_dir = '../data/'\n",
    "journalist = 'Lingling_Wei'\n",
    "batch_size = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c97138bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_set(set_list, n):\n",
    "    indices = np.arange(n)\n",
    "    np.random.shuffle(indices)\n",
    "\n",
    "    # Split sizes\n",
    "    train_size = int(0.7 * n)\n",
    "    validation_size = int(0.3 * n)\n",
    "    test_size = n\n",
    "    # Split indices\n",
    "    train_indices = list(indices[:train_size])\n",
    "    dev_indices = list(indices[train_size:train_size+validation_size])\n",
    "    test_indices = list(indices[train_size+validation_size:])\n",
    "\n",
    "    get_items_tr = itemgetter(*train_indices)  # Creates a callable for indexing\n",
    "    get_items_dev = itemgetter(*dev_indices)\n",
    "    get_items_te = itemgetter(*test_indices)\n",
    "    result_tr = list(get_items_tr(set_list))\n",
    "    result_dev = list(get_items_dev(set_list))\n",
    "    result_te = list(get_items_te(set_list))\n",
    "\n",
    "    result_train = result_tr if isinstance(result_tr, list) else [result_tr]\n",
    "    result_val = result_dev if isinstance(result_dev, list) else [result_dev]\n",
    "    result_test = result_te if isinstance(result_te, list) else [result_te]\n",
    "\n",
    "    return result_train, result_val, result_test\n",
    "\n",
    "def load_data(data_dir, journalist, classes, batch_size, collate):\n",
    "    ### Data (normalize input inter-event times, then padding to create dataloaders)\n",
    "    num_classes, num_sequences = 0, 0\n",
    "    seq_dataset = []\n",
    "    arr = []\n",
    "    dp = []\n",
    "    rel = []\n",
    "    \n",
    "    split = [98, 99]\n",
    "    # JiayangFan: 8: 84\n",
    "    # muyixiao: 4: 16\n",
    "    # lingling: 8, 99\n",
    "    # marianna: 2: 10\n",
    "    val = 0\n",
    "    journal_sort = pd.read_csv((os.path.join(data_dir, f'{journalist}/{journalist}_conv_labels.csv')))\n",
    "    ids = []\n",
    "    for item in list(journal_sort['conversation_id']):\n",
    "        if item not in ids:\n",
    "            ids.append(item)\n",
    "    id_pair = {}\n",
    "    id_conv = {}\n",
    "    for idx in ids:\n",
    "        id_pair[idx], id_conv[idx] = create_conversation_list(journal_sort[journal_sort['conversation_id']==idx], idx)\n",
    "    id_data, uid, data, label = create_data(journal_sort, ids)\n",
    "    prob = pkl.load(open(os.path.join(data_dir, f'{journalist}/{journalist}_edgeprob.pkl'), 'rb'))\n",
    "    \n",
    "    with open(os.path.join(data_dir, f'{journalist}/{journalist}_global_path.txt'), \"r\") as f:\n",
    "        for line in tqdm(f, total=get_number_of_lines(f)):\n",
    "            dp.append(json.loads(line.strip()))\n",
    "\n",
    "    with open(os.path.join(data_dir, f'{journalist}/{journalist}_local_path.txt'), \"r\") as f:\n",
    "        for line in tqdm(f, total=get_number_of_lines(f)):\n",
    "            rel.append(json.loads(line.strip()))\n",
    "    \n",
    "    global_input = convert_global(dp, id_data)\n",
    "    local_data = convert_local(rel)\n",
    "    local_mat = generate_local_mat(local_data, id_data)\n",
    "    local_input = create_mat(local_mat, mat_type='concat')\n",
    "    logging.info(f'loaded split {journalist}...')\n",
    "    # data - dict: dim_process, devtest, args, train, dev, test, index (train/dev/test given as)\n",
    "    # data[split] - list dicts {'time_since_start': at, 'time_since_last_event': dt, 'type_event': mark} or\n",
    "    # data[split] - dict {'arrival_times', 'delta_times', 'marks'}\n",
    "    # data['dim_process'] = Number of accounts = 119,298\n",
    "    # num_sequences: number of conversations of a journalist\n",
    "    num_classes = classes\n",
    "    #num_sequences += len(data[split]['arrival_times'])\n",
    "    num_sequences = len(set(journal_sort['conversation_id']))\n",
    "    \n",
    "    id_train, id_dev, id_test = id_data[:split[0]], id_data[split[0]:split[1]], id_data[split[1]:]\n",
    "    uid_train, uid_dev, uid_test = uid[:split[0]], uid[split[0]:split[1]], uid[split[1]:]\n",
    "    X_train, X_dev, X_test = data[:split[0]], data[split[0]:split[1]], data[split[1]:]\n",
    "    prob_train, prob_dev, prob_test = prob[:split[0]], prob[split[0]:split[1]], prob[split[1]:]\n",
    "    global_train, global_dev, global_test = global_input[:split[0]], global_input[split[0]:split[1]], global_input[split[1]:]\n",
    "    local_train, local_dev, local_test = local_input[:split[0]], local_input[split[0]:split[1]], local_input[split[1]:]\n",
    "    label_train, label_dev, label_test = label[:split[0]], label[split[0]:split[1]], label[split[1]:]\n",
    "\n",
    "    # id_train, id_dev, id_test = id_data[split[0]:split[1]], id_data[:split[0]], id_data[split[1]:]\n",
    "    # uid_train, uid_dev, uid_test = uid[split[0]:split[1]], uid[:split[0]], uid[split[1]:]\n",
    "    # X_train, X_dev, X_test = data[split[0]:split[1]], data[:split[0]], data[split[1]:]\n",
    "    # prob_train, prob_dev, prob_test = prob[split[0]:split[1]], prob[:split[0]], prob[split[1]:]\n",
    "    # global_train, global_dev, global_test = global_input[split[0]:split[1]], global_input[:split[0]], global_input[split[1]:]\n",
    "    # local_train, local_dev, local_test = local_input[split[0]:split[1]], local_input[:split[0]], local_input[split[1]:]\n",
    "    # label_train, label_dev, label_test = label[split[0]:split[1]], label[:split[0]], label[split[1]:]\n",
    "\n",
    "    # n = 16\n",
    "    # id_train, id_dev, id_test = get_set(id_data, n)\n",
    "    # uid_train, uid_dev, uid_test = get_set(uid, n)\n",
    "    # X_train, X_dev, X_test = get_set(data, n)\n",
    "    # prob_train, prob_dev, prob_test = get_set(prob, n)\n",
    "    # global_train, global_dev, global_test = get_set(global_input, n)\n",
    "    # local_train, local_dev, local_test = get_set(local_input, n)\n",
    "    # label_train, label_dev, label_test = get_set(label, n)\n",
    "    \n",
    "    d_train = TreeDataset(id_train, uid_train, X_train, prob_train, global_train, local_train, label_train)\n",
    "    d_val = TreeDataset(id_dev, uid_dev, X_dev, prob_dev, global_dev, local_dev, label_dev)  \n",
    "    d_test  = TreeDataset(id_test, uid_test, X_test, prob_test, global_test, local_test, label_test)   \n",
    "\n",
    "    # for padding input sequences to maxlen of batch for running on gpu, and arranging them by length efficient\n",
    "    collate = collate  \n",
    "    dl_train = torch.utils.data.DataLoader(d_train, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "    dl_val = torch.utils.data.DataLoader(d_val, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "    dl_test = torch.utils.data.DataLoader(d_test, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "    return dl_train, dl_val, dl_test\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45d59d36",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 452/452 [00:00<00:00, 3346.82it/s]\n",
      "100%|██████████| 452/452 [00:00<00:00, 42183.82it/s]\n"
     ]
    }
   ],
   "source": [
    "# data, labels, prob, global_path, local_path, torch.tensor(masks)\n",
    "train, val, test = load_data(out_dir, journalist, 3, batch_size, collate)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2554561e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# val\n",
    "with open(os.path.join(out_dir, f'{journalist}/strat_val.pkl'), 'rb') as file:\n",
    "    strat_val = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/true_labels.pkl'), 'rb') as file:\n",
    "    true_labels = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/pred_val.pkl'), 'rb') as file:\n",
    "    pred_val = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/output_val.pkl'), 'rb') as file:\n",
    "    output_val = pickle.load(file)\n",
    "\n",
    "# with open(os.path.join(out_dir, f'{journalist}/predicted.pkl'), 'rb') as file:\n",
    "#     predicted = pickle.load(file)\n",
    "# train\n",
    "with open(os.path.join(out_dir, f'{journalist}/strat_tr.pkl'), 'rb') as file:\n",
    "    strat_train = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/pred_tr.pkl'), 'rb') as file:\n",
    "    pred_train = pickle.load(file)\n",
    "    \n",
    "with open(os.path.join(out_dir, f'{journalist}/output.pkl'), 'rb') as file:\n",
    "    output_train = pickle.load(file)\n",
    "# test\n",
    "with open(os.path.join(out_dir, f'{journalist}/strat_te.pkl'), 'rb') as file:\n",
    "    strat_test = pickle.load(file)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}/pred_te.pkl'), 'rb') as file:\n",
    "    pred_test = pickle.load(file)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e440bbfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels_tr = []\n",
    "strat_tr = []\n",
    "uid_tr = []\n",
    "output_tr = []\n",
    "pred_tr = []\n",
    "for i, item in enumerate(train):  # Assuming 'val' is your validation dataset\n",
    "    # Forward pass\n",
    "    #print(i)\n",
    "    mask = item.masks.float()\n",
    "    mask_bool = mask.bool()\n",
    "    labels = item.labels[mask_bool]\n",
    "\n",
    "    strat_temp = torch.Tensor(strat_train[i])\n",
    "    pred_temp = torch.Tensor(pred_train[i])\n",
    "    output_temp = torch.Tensor(output_train[i])\n",
    "\n",
    "    # output_temp = torch.Tensor(output_val[i])\n",
    "    # pred_temp = torch.Tensor(pred_val[i])\n",
    "    # strat_temp = torch.Tensor(strat_val[i])\n",
    "    \n",
    "    output_tr.append(output_temp[mask_bool].tolist())\n",
    "    pred_tr.append(pred_temp[mask_bool].tolist())\n",
    "    uid_tr.append(item.uid[mask_bool].tolist()) \n",
    "    strat_tr.append(strat_temp[mask_bool].tolist())\n",
    "    labels_tr.append(labels.tolist())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7ef4b03",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_te = []\n",
    "strat_te = []\n",
    "for i, item in enumerate(test):  # Assuming 'val' is your validation dataset\n",
    "    # Forward pass\n",
    "    #print(i)\n",
    "    mask = item.masks.float()\n",
    "    mask_bool = mask.bool()\n",
    "    labels = item.labels[mask_bool]\n",
    "\n",
    "    strat_temp = torch.Tensor(strat_test[i])\n",
    "    pred_temp = torch.Tensor(pred_test[i])\n",
    "\n",
    "    pred_te.append(pred_temp[mask_bool].tolist())\n",
    "    strat_te.append(strat_temp[mask_bool].tolist())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b4387fd",
   "metadata": {},
   "source": [
    "## User Cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4abff0f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "user = np.array([item for sublist in output_tr for item in sublist])\n",
    "labels = np.array([item for sublist in pred_tr for item in sublist])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65a94f07",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27a4e96b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.manifold import TSNE\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# # Standardize the data\n",
    "# X_standardized = StandardScaler().fit_transform(user)  # X is your multi-dimensional data\n",
    "\n",
    "# # Run t-SNE\n",
    "# tsne = TSNE(n_components=2, perplexity=50, learning_rate=200, n_iter=1000)\n",
    "# X_tsne = tsne.fit_transform(X_standardized)\n",
    "\n",
    "# # Assuming X_tsne is your t-SNE output and labels is an array of your data point labels\n",
    "# unique_labels = np.unique(labels)\n",
    "# colors = plt.cm.rainbow(np.linspace(0, 1, len(unique_labels)))\n",
    "\n",
    "# plt.figure(figsize=(5, 4))\n",
    "# # Plot each cluster with a different color\n",
    "# for i, label in enumerate(unique_labels):\n",
    "#     plt.scatter(X_tsne[labels == label, 0], X_tsne[labels == label, 1], color=colors[i], label=label, s=10)\n",
    "\n",
    "# plt.xlabel('t-SNE feature 1')\n",
    "# plt.ylabel('t-SNE feature 2')\n",
    "# plt.title('t-SNE Visualization with Cluster Coloring')\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0beabfb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from sklearn.decomposition import PCA\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Example: Replace this with your actual multi-dimensional data\n",
    "data = user  # Random data with 5 dimensions\n",
    "\n",
    "\n",
    "pca = PCA(n_components=2)\n",
    "pca.fit(data)\n",
    "data_2d = pca.transform(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "992a48f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "labe = []\n",
    "for i, item in enumerate(data_2d):\n",
    "    if item[1] > 2.5 and item[0] > 5:\n",
    "        labe.append(0)\n",
    "    else:\n",
    "        labe.append(labels[i])\n",
    "group = labe\n",
    "cdict = {0: 'Red', 1: 'Green', 2: 'Blue'}\n",
    "unique_labels = np.unique(labe)\n",
    "colors = plt.cm.rainbow(np.linspace(0, 1, len(unique_labels)))\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for g in np.unique(group):\n",
    "    ix = np.where(group == g)\n",
    "    ax.scatter(data_2d[:, 0][ix], data_2d[:, 1][ix], c = cdict[g], label = g, s = 15, zorder=3)\n",
    "ax.legend()\n",
    "plt.gca().spines['top'].set_visible(False)\n",
    "plt.gca().spines['right'].set_visible(False)\n",
    "plt.gca().spines['left'].set_visible(False)\n",
    "plt.gca().spines['bottom'].set_visible(False)\n",
    "plt.gca().set_facecolor('#f0f0f0')  # Use a light grey background, you can choose any color code\n",
    "plt.grid(True, which='both', axis='both', color='white', linestyle='-', linewidth=0.5, zorder=0)\n",
    "\n",
    "\n",
    "plt.tick_params(bottom=False, left=True)\n",
    "plt.title(\"Representation of User Clusters\")\n",
    "plt.xlabel(\"t-SNE feature 1\")\n",
    "plt.ylabel(\"t-SNE feature 2\")\n",
    "plt.legend(['Attackers', 'Bystanders', 'Supporters'])\n",
    "plt.savefig(f'../result/cluster_{journalist}.png', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f16f789",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_label = {}\n",
    "for i in range(len(labels_tr)):\n",
    "    for j in range(len(labels_tr[i])):\n",
    "        if uid_tr[i][j] not in user_label.keys():\n",
    "            user_label[uid_tr[i][j]] = ([labels_tr[i][j]], [strat_tr[i][j]])\n",
    "        else:\n",
    "            user_label[uid_tr[i][j]][0].append(labels_tr[i][j])\n",
    "            user_label[uid_tr[i][j]][1].append(strat_tr[i][j])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8349ee24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.08586945, 0.10313469, 0.05693509, 0.10864182, 0.17370731,\n",
       "       0.25151843, 0.06475481, 0.15543842])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean([strat_tr[0][0]], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d03da05",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_strat = {0:[], 1:[], 2:[]}\n",
    "for k, v in user_label.items():\n",
    "    if 0 in v[0]:\n",
    "        user_strat[0].append(np.mean(v[1], axis=0))\n",
    "    elif 2 in v[0]:\n",
    "        user_strat[2].append(np.mean(v[1], axis=0))\n",
    "    else:\n",
    "        user_strat[1].append(np.mean(v[1], axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d4d469f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.12677151 0.11697769 0.16980086 0.12518489 0.09913733 0.13606339\n",
      " 0.10633168 0.11973265]\n",
      "[0.14566841 0.11490491 0.13483612 0.12687582 0.10511835 0.11471075\n",
      " 0.14982386 0.10806179]\n",
      "[0.12547498 0.10136525 0.12200688 0.13564198 0.12121297 0.17086338\n",
      " 0.11223759 0.11119698]\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(user_strat[0], axis=0))\n",
    "print(np.mean(user_strat[1], axis=0))\n",
    "print(np.mean(user_strat[2], axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "091bf24d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77 150 141\n"
     ]
    }
   ],
   "source": [
    "strat_0 = []\n",
    "strat_1 = []\n",
    "strat_2 = []\n",
    "for i in range(len(labels_tr)):\n",
    "    for j, item in enumerate(labels_tr[i]):\n",
    "        if item == 0:\n",
    "            strat_0.append(strat_tr[i][j])\n",
    "        elif item == 1:\n",
    "            strat_1.append(strat_tr[i][j])\n",
    "        elif item == 2:\n",
    "            strat_2.append(strat_tr[i][j])\n",
    "\n",
    "print(len(strat_0), len(strat_1), len(strat_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2b25bc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#scale = np.array([1e-1, 1, 1e2, 1e2, 1e2, 1e2, 1e2, 1e2])\n",
    "scale = np.array([0.4, 5e0, 5e0, 1e1, 1e1, 1e1, 1e1, 1e1])\n",
    "scale1 = np.array([1.5, 2.5, 1.5, 1.5, 2.5, 1.5, 1.5, 1.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a751924d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.12882457 0.10887161 0.19268564 0.11576389 0.10115023 0.12657945\n",
      " 0.1013096  0.12481501] [0.14318181 0.10525518 0.13969871 0.13371258 0.10855815 0.11665981\n",
      " 0.13547747 0.11745629] [0.13100814 0.0964545  0.14213638 0.12795892 0.1187837  0.1704576\n",
      " 0.09498744 0.11821333]\n"
     ]
    }
   ],
   "source": [
    "ms_0 = (np.mean(np.array(strat_0), 0)) \n",
    "ms_1 = (np.mean(np.array(strat_1), 0)) \n",
    "ms_2 = (np.mean(np.array(strat_2), 0)) \n",
    "print(ms_0, ms_1, ms_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8a2d03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAGGCAYAAADW9O5xAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVd0lEQVR4nO3deVxU5f4H8M8AMiA7KuAGiBiKCiII7rigaGaaZGqmaLlkkhq3TK4mWppWXJeS61ZqJV4ozSVTUlFccF9wQ0kUxUTADRVREOb5/TE/5jqyDYJzONzP29d5vTzPc5bvDDPznWeZcxRCCAEiIiIJGUgdABEREZMRERFJjsmIiIgkx2RERESSYzIiIiLJMRkREZHkmIyIiEhyTEZERCQ5JiMiIpLcS0tGCoUCmzZtqvLjduvWDVOmTNGsOzs7Y9GiRVV+npLOJRUhBMaNGwdbW1soFAokJiZKHRKV4WW99l+ELq/hNWvWwNrausxtRo0ahYEDB1ZZXOV5/n2dkZGBXr16wczMTBNrSWUkY6ICgoODBQABQBgZGQk7OzsREBAgfvjhB1FYWKi17c2bN8WTJ090Oi4AsXHjRp22vXPnjnjw4IFm3cnJSSxcuFDXh1CiPXv2CADi3r17ZZ5LKtu2bRO1atUSCQkJ4ubNm+Lp06fFtlm9erWwsrIqcf+KPL8vQ3BwsAgPDy+1vqCgQMybN0+4ubkJExMTYWNjI3x9fcXKlSs12/j7+4vJkydXWUxV8bopTUVe+y+bLu+Xsl47RbKzs4u9PyoqPDxc8/lhaGgo6tSpI7p06SIWLlxY7PnKysoSjx490qxPnTpVtGzZUvz1118iMzOz1DIpVeQ1eunSJTF69GjRuHFjYWxsLBo0aCB69Ogh1q5dW+L7+3+BUUWTV58+fbB69WoUFhYiMzMTsbGxmDx5MtavX48tW7bAyEh9SAcHh6rLmADy8/NhbGwMW1vbKj1uWfR5rrJcvnwZ9evXR8eOHaUOpZiiv0tlzJ49G8uXL8eSJUvg4+ODBw8e4Pjx47h3716FjiOEQGFhoeY1KJWqfu1XRlW9hq2srKrkOC1btsSuXbugUqlw584dxMfHY86cOfj5558RHx8PCwsLAEC9evW09rt8+TK8vb3RrFmzMssqqipevxV19OhRBAQEoGXLloiMjETz5s0BAMePH0dkZCRatWoFT0/PEvd9+vQpatWqpc9w9acimSs4OFgMGDCgWHlcXJwAoPVNFs98G8/LyxMTJ04UDg4OQqlUCkdHR/Hll18KIdTf1PD/35YACCcnJyGE+luUp6enWLlypXB2dhYKhUIIUfzbh5OTk/j888/F0KFDRe3atUWDBg3EkiVLNPWpqakCgDh16pSm7N69ewKA2LNnj6b+2SU4OLjEc929e1eMGDFCWFtbC1NTU9GnTx/x119/aeqLvmHGxsaK5s2bCzMzMxEYGCjS09PLfF7j4+NFu3bthLGxsXBwcBCffvqp5tvRs63RZ5+f5+naMrp79654++23Rd26dYWJiYlwdXUVq1at0myblpYmBg8eLKysrISNjY14/fXXRWpqqqa+6DUwZ84cUb9+feHs7CyEECIyMlK4uroKpVIp7OzsRFBQkNY+ZbWMPD09xaxZs0qtf/45ACBSU1M1Ldpt27aJtm3bilq1aok9e/aIlJQU8frrrws7OzthZmYmfHx8xM6dOzXH8/f3L3a8Ivv37xedO3cWJiYmolGjRuLDDz8UOTk5mvr09HTx6quvChMTE+Hs7CyioqKKtTbwXEu0vOd0z549ol27dqJ27drCyspKdOzYUVy9erXE5yIoKEhMnDhRsz558mQBQFy4cEEIoX6v1a5dW/N4n30Nl/a4dXndPv/e9/f3Fx9++KH45JNPhI2NjbC3ty/zbyzEf9/Tz7tw4YIwNjYW06dP15Q9+5w+/xkRHBxcYpkQ6vf2e++9J+rWrSssLCxE9+7dRWJiYrEYnv9c0XW/n376STg5OQlLS0sxZMgQTauztNfo81QqlWjRooXw9vYu1pv07DZC/PezKzo6WnTt2lUolUqxevVqUVhYKGbPni0aNmwojI2Nhaenp9i+fbtm/5J6ek6dOqUVU9HffOPGjZr3be/evUVaWppmn8TERNGtWzdhbm4uLCwsRNu2bcWxY8dKjLkqVMmYUY8ePeDp6YnffvutxPpvv/0WW7ZswS+//ILk5GRERUXB2dkZAHDs2DEAwOrVq3Hz5k3NOgCkpKRgw4YN+O2338ocJ/nmm2/g6emJU6dOYdq0aZg8eTJ27typU+yNGzfGhg0bAADJycm4efMmFi9eXOK2o0aNwvHjx7FlyxYcOnQIQgi8+uqrePr0qWab3NxcRERE4Oeff8a+ffuQlpaGjz/+uNTz37hxA6+++iratWuH06dPY+nSpfjhhx8wZ84cAMDixYvx+eefo1GjRsWenxfx2WefISkpCdu3b8eFCxewdOlS1K1bF4D6W1dgYCAsLCywf/9+JCQkwNzcHH369EF+fr7mGHFxcUhOTsbOnTuxdetWHD9+HJMmTcLnn3+O5ORkxMbGomvXrjrH5ODggN27d+PWrVsl1i9evBgdOnTA2LFjcfPmTdy8eRONGzfW1E+bNg3z58/HhQsX4OHhgZycHLz66quIi4vDqVOn0KdPH/Tv3x9paWkAgN9++w2NGjXC559/rjkeoP6m3adPHwQFBeHMmTOIiYnBgQMHEBISojnXyJEjkZ6ejvj4eGzYsAErVqxAVlZWqY+tvOe0oKAAAwcOhL+/P86cOYNDhw5h3LhxUCgUJR7P398f8fHxmvW9e/eibt26mrJjx47h6dOnJbaiS3vcQMVftwDw448/wszMDEeOHMHXX3+Nzz//XOf33bOaN2+Ovn37lvr5cezYMfTp0wdvvfWW5v1ZUhkADB48GFlZWdi+fTtOnDiBtm3bomfPnrh7967meCV9ruiy3+XLl7Fp0yZs3boVW7duxd69ezF//nwA5b9GiyQmJuLChQv4+OOPYWBQ8sfv83/7os+0CxcuIDAwEIsXL8a//vUvRERE4MyZMwgMDMTrr7+OS5cu6f6kQ/03nzt3Ln766SckJCQgOzsbQ4cO1dQPHz4cjRo1wrFjx3DixAlMmzbt5bbKKpK5SmsZCSHEkCFDRIsWLTTreObb4Ycffih69OihyfjPA4qPaYSHh4tatWqJrKwsrfKSWkZ9+vQpFkvfvn2FEOW3jIQofczo2XP99ddfAoBISEjQ1N++fVuYmpqKX375RQih/rYBQKSkpGi2iYyMFPb29iU+biGE+Oc//ync3Ny0npvIyEhhbm6u+ea0cOHCUltERXRtGfXv31+MHj26xO1+/vnnYrHk5eUJU1NT8eeffwoh1K8Be3t7kZeXp9lmw4YNwtLS8oXH186fPy9atGghDAwMROvWrcX48ePFtm3btLYpqT++6O+2adOmcs/RsmVL8d1332nWSxo7ee+998S4ceO0yvbv3y8MDAzE48ePxYULFwQArW+Hly5dEgBKbRmV95zeuXNHABDx8fHlPgYhhDhz5oxQKBQiKytL3L17VxgbG4svvvhCDBkyRAghxJw5c0THjh0125f0filpzKi8121JLaPOnTtrHaddu3bi008/LTX20lpGQgjx6aefClNT01LjHDBggKb1U1rZ/v37haWlZbHxp6ZNm4rly5drYnj+c0XX/WrXrq31Gv/kk0+En5+fZl2XMaPo6GgBQJw8eVJTlpmZKczMzDRLZGSkEOK/n12LFi3SOkaDBg3E3LlztcratWsnPvjgAyGE7i0jAOLw4cOabYpe30eOHBFCCGFhYSHWrFlT5uOpSlU2m04IUeq3uVGjRiExMRFubm6YNGkSduzYodMxnZycivUdl6RDhw7F1i9cuKDTOXR14cIFGBkZwc/PT1NWp04duLm5aZ2rdu3aaNq0qWa9fv36ZX5zvnDhAjp06KD13HXq1Ak5OTn4+++/q/QxAMCECRMQHR2NNm3aYOrUqTh48KCm7vTp00hJSYGFhQXMzc1hbm4OW1tbPHnyBJcvX9Zs17p1a61+9l69esHJyQkuLi4YMWIEoqKikJubq3NM7u7uOHfuHA4fPox3330XWVlZ6N+/P8aMGaPT/j4+PlrrOTk5+Pjjj9GiRQtYW1vD3NwcFy5c0LSMSnP69GmsWbNG89jNzc0RGBgIlUqF1NRUJCcnw8jICG3bttXs4+rqChsbmzKPWdZzamtri1GjRiEwMBD9+/fH4sWLtVosz2vVqhVsbW2xd+9e7N+/H15eXnjttdewd+9eAOqWUrdu3XR41rRV9HULAB4eHlrruuxTmrI+P3R1+vRp5OTkoE6dOlp/w9TUVK3X7/OfK7ru5+zsrBnTAir3eJ9Vp04dJCYmIjExEdbW1lq9EID26/vBgwdIT09Hp06dtLbp1KlThT/zjIyM0K5dO8168+bNYW1trTlOaGgoxowZg4CAAMyfP1/ruXgZqmyk98KFC2jSpEmJdW3btkVqaiq2b9+OXbt24a233kJAQADWr19f5jHNzMwqHVdRU1g8cw/BZ7vVqtrzzViFQqF17pfF0tISjx49gkql0mr+Z2dnA/jvAHTfvn1x7do1bNu2DTt37kTPnj0xceJEREREICcnB97e3oiKiip2/GffvM//XSwsLHDy5EnEx8djx44dmDlzJmbNmoVjx47pPOXWwMAA7dq1Q7t27TBlyhSsXbsWI0aMwPTp00t9XZUWz8cff4ydO3ciIiICrq6uMDU1xZtvvlnsTf68nJwcjB8/HpMmTSpW5+joiL/++kunx/L8Mct7TlevXo1JkyYhNjYWMTExmDFjBnbu3In27dsX20ehUKBr166Ij4+HUqlEt27d4OHhgby8PJw7dw4HDx4st3utJC/yui1pH5VKVeFzA2V/fugqJycH9evX1+rGLPLs6/D514uu+1XF4y2abJGcnAwvLy8AgKGhIVxdXQGgxMk3Ff0crKrPvFmzZuHtt9/GH3/8ge3btyM8PBzR0dF44403KnwsXVRJy2j37t04e/YsgoKCSt3G0tISQ4YMwcqVKxETE4MNGzZo+mNr1aqFwsLCFz7/4cOHi623aNECwH/f8M9+23x+/KnoW35ZMbRo0QIFBQU4cuSIpuzOnTtITk6Gu7v7C8feokULzfhTkYSEBFhYWKBRo0Y6H8fNzQ0FBQXFHtvJkycBAK+88oqmrF69eggODsbatWuxaNEirFixAoD6S8OlS5dgZ2cHV1dXraW82VRGRkYICAjA119/jTNnzuDq1avYvXu3zvE/r+g5ffToEQD130jX10hCQgJGjRqFN954A61bt4aDgwOuXr2qtU1Jx2vbti2SkpKKPXZXV1cYGxtrnuNTp05p9klJSSlz1p+uz6mXlxfCwsJw8OBBtGrVCuvWrSv1mEXjRvHx8ejWrRsMDAzQtWtXfPPNN8jLyyv2rbm8xy21ixcvIjY2tszPD120bdsWGRkZMDIyKvZcF42LVuV+z9PlufXy8kLz5s0RERHxQonb0tISDRo0QEJCglZ5QkKC5j2jy2ceABQUFOD48eOa9eTkZGRnZ2s+OwH158ZHH32EHTt2YNCgQVi9enWFY9ZVhZNRXl4eMjIycOPGDZw8eRJffvklBgwYgNdeew0jR44scZ8FCxbgP//5Dy5evIi//voLv/76KxwcHDTfOpydnREXF4eMjIwKT+cF1H+Ir7/+Gn/99RciIyPx66+/YvLkyQAAU1NTtG/fXjPAvXfvXsyYMUNrfycnJygUCmzduhW3bt1CTk5OsXM0a9YMAwYMwNixY3HgwAGcPn0a77zzDho2bIgBAwZUOOYiH3zwAa5fv44PP/wQFy9exObNmxEeHo7Q0NBSBzhL0rJlS/Tu3Rvvvvsu4uLikJqaitjYWHzwwQcYMmQIGjZsCACYOXMmNm/ejJSUFJw/fx5bt27VvPiGDx+OunXrYsCAAdi/fz9SU1MRHx+PSZMmldlluHXrVnz77bdITEzEtWvX8NNPP0GlUsHNzU2n2N98800sXLgQR44cwbVr1xAfH4+JEyfilVde0Ux7dXZ2xpEjR3D16lXcvn27zDdys2bNNIPTp0+fxttvv11se2dnZ+zbtw83btzA7du3AQCffvopDh48iJCQECQmJuLSpUvYvHmzZgJD8+bNERAQgHHjxuHo0aM4deoUxo0bB1NT01K7mMp7TlNTUxEWFoZDhw7h2rVr2LFjBy5duqT1gfC8bt26ISkpCefPn0fnzp01ZVFRUfDx8Snzm3RJj1ufCgoKkJGRgfT0dJw9exbfffcd/P390aZNG3zyySeVOnZAQAA6dOiAgQMHYseOHbh69SoOHjyI6dOna33oVtV+z9PlNapQKLB69WokJyejU6dO2LJlCy5duoSkpCQsW7YMt27dgqGhYZnn+eSTT/DVV18hJiYGycnJmDZtGhITEzWfea6urmjcuDFmzZqFS5cu4Y8//sC//vWvYsepVasWPvzwQxw5cgQnTpzAqFGj0L59e/j6+uLx48cICQlBfHw8rl27hoSEBBw7dqzM12WlVWSA6fkfvdarV08EBASIVatWFZumiGcGcVesWCHatGkjzMzMhKWlpejZs6fWAN6WLVuEq6urMDIyKja1+3klDcjOnj1bDB48WNSuXVs4ODiIxYsXa+2TlJQkOnToIExNTUWbNm3Ejh07tCYwCCHE559/LhwcHIRCoSh3areVlZUwNTUVgYGBJU7tftbGjRtFeU9zWVO7hdBtAoMQ6okZkyZNEk2bNhWmpqaiWbNmYurUqeLhw4eabb744gvRokULYWpqKmxtbcWAAQPElStXNPU3b94UI0eOFHXr1hVKpVK4uLiIsWPHivv37wshSp7Esn//fuHv7y9sbGyEqamp8PDwEDExMeXGW2TFihWie/fuol69esLY2Fg4OjqKUaNGaU1vTk5OFu3btxempqbFpnY/P/EkNTVVdO/eXZiamorGjRuLJUuWFPtbHjp0SHh4eAilUqn19zl69Kjo1auXMDc3F2ZmZsLDw0NrsDg9PV307dtXKJVK4eTkJNatWyfs7OzEsmXLNNvguQk5ZT2nGRkZYuDAgaJ+/frC2NhYODk5iZkzZ5Y67VcIIQoLC4WNjY3W4HnRAPW0adO0ttXlcevyui1pAsPzg/UlTTJ41vM/erW1tRWdO3cu8UevLzKBQQghHjx4ID788EPRoEEDUatWLdG4cWMxfPhwzZTl0j5XXmS/59+XJb1GS5OcnCyCg4NFo0aNhJGRkbCyshJdu3YVy5cv17z3S5p8JYT67z9r1izRsGFDUatWrWJTu4UQ4sCBA6J169bCxMREdOnSRfz6668lTu3esGGDcHFxEUqlUgQEBIhr164JIdSTbIYOHar1o9yQkBDx+PHjUh9TZSmE0MOABlEN9ffff6Nx48bYtWsXevbsKXU4RDpZs2YNpkyZohlTrg6k/ak6kczs3r0bOTk5aN26NW7evImpU6fC2dm5Qr+rIqLimIyIKuDp06f45z//iStXrsDCwgIdO3ZEVFRUzb1EC5GesJuOiIgkx/sZERH9D4mMjISzszNMTEzg5+eHo0ePlrrt+fPnERQUBGdnZygUihJv1zNr1iwoFAqtpWgWbEUwGRER/Y+IiYlBaGgowsPDcfLkSXh6eiIwMLDUK0nk5ubCxcUF8+fPL/Nq9C1bttRck+/mzZs4cOBAhWNjMiIi+h+xYMECjB07FqNHj4a7uzuWLVuG2rVrY9WqVSVu365dO3zzzTcYOnQolEplqcc1MjKCg4ODZqnIj4WLMBkREclYXl4eHjx4oLXk5eUV2y4/Px8nTpxAQECApszAwAABAQE4dOhQpWK4dOkSGjRoABcXFwwfPrzc60CWhLPpytB8evFfLevba52k/xP9OaPiL6yq5jbFUeoQAACvtajcxTyrwsJtBVKHgCmvSv+6BIB/75T+uTj2z9BK7d+67T8qtX/Q6xaYPXu2Vll4eDhmzZqlVXb79m0UFhbC3t5eq9ze3h4XL1584fP7+flhzZo1cHNzw82bNzF79mx06dIF586d07qwbHmqxyuKiIheSFhYGEJDtRNiWV1qVa1v376a/3t4eMDPzw9OTk745Zdf8N577+l8HCYjIiIZUyqVOiWfunXrwtDQEJmZmVrlmZmZZU5OqChra2u88sorSElJqdB+HDMiIpKSopKLjoyNjeHt7Y24uDhNmUqlQlxcXLF7wlVGTk4OLl++jPr161doP7aMiIikVMmbClZEaGgogoOD4ePjA19fXyxatAiPHj3C6NGjAQAjR45Ew4YNMW/ePADqSQ9JSUma/9+4cQOJiYkwNzfX3IPp448/Rv/+/eHk5IT09HSEh4fD0NAQw4YNq1BsTEZERFLS45yYIUOG4NatW5g5cyYyMjLQpk0bxMbGaiY1pKWlad26Jj09XXMTQACIiIhARESE5p5agPpiwcOGDcOdO3dQr149dO7cGYcPH9bpLt3PYjIiIpKSnidohoSEaO7R9bzn73br7Oxc7h1/o6OjqyQujhkREZHk2DIiIpKU9L9dqw6YjIiIJCSYiwAwGRERSYvJCACTERGRtPQ4tbs64wQGIiKSHJMRERFJjt10RERSYi8dgBqWjHJzcxEdHY28vDy8+uqrcHJykjokIqKyccwIgIyT0XvvvYcjR47g3LlzANTXTWrfvr1m3crKCrt379a6lAURUbXDXARAxmNGe/bswaBBgzTr69atw7lz5xAVFYVz587BwcGh2A2niIiqG1HJpaaQbTLKyMiAs7OzZn3Tpk3w8fHBsGHD4O7ujrFjx+LIkSPSBUhEpAuFonJLDSHbZGRmZobs7GwAQEFBAeLj4xEYGKipt7CwwP379yWKjoiIKkK2Y0Zt27bFypUr0b17d2zZsgUPHz5E//79NfWXL18udq93IqJqp+Y0bipFtslo7ty56N27N3x8fCCEwJtvvglfX19N/caNG9GpUycJIyQi0gWzESDjZOTj44Pk5GQcPHgQ1tbW8Pf319RlZ2fjgw8+0CojIqqWmIsAyDQZPX78GNOnT0f37t0xYMCAYvXW1taYPHmyBJEREVUQkxEAmU5gMDU1xfLly5GZmSl1KERElSIUikotNYUskxEAeHt7a37gSkRE8ibbZLRo0SJER0fj+++/R0FBgdThEBFRJchyzAgARo0aBQMDA4wfPx6TJk1Cw4YNYWpqqrWNQqHA6dOnJYqQiEgHNairrTJkm4xsbW1Rp04duLm5SR0KEdGLYy4CIONkFB8fL3UIRESVVpOuL1cZsk1GREQ1ArvpAMh4AgMAPHjwAPPnz0dgYCC8vLxw9OhRAMDdu3exYMECpKSkSBwhERHpQrYto7///hv+/v64fv06mjVrhosXLyInJweAejxp+fLluHbtGhYvXixxpEREZWDDCICMk9Enn3yChw8fIjExEXZ2drCzs9OqHzhwILZu3SpRdEREOmI3HQAZd9Pt2LEDkyZNgru7OxQl/DFdXFxw/fp1CSIjItIdb66nJtuW0ePHj1GvXr1S6x8+fKjHaIiIXhAbRgBk3DJyd3fHvn37Sq3ftGkTvLy89BgREdEL4J1eAcg4GU2ZMgXR0dH46quvNHd0ValUSElJwYgRI3Do0CF89NFHEkdJRES6kG033TvvvINr165hxowZmD59OgCgT58+EELAwMAAX375JQYOHChtkEREpBPZJiMAmD59OkaMGIENGzYgJSUFKpUKTZs2xaBBg+Di4iJ1eERE5apJt4GoDNkmo02bNmHgwIFwdHQstTvu008/xVdffaXnyIiIKoC5CICMx4yGDh2K2NjYUuvff/99RERE6DEiIiJ6UbJNRiNHjsSgQYMQFxenVa5SqfD2229j5cqViIyMlCg6IiLd8E6varLtpluxYgXy8vIwYMAAbN++HV26dEF+fj4GDx6M7du346effsLw4cOlDpOIiHQg22QEAKtXr0ZeXh769euH9evX4+uvv0ZCQgJ+/fVXDBgwQOrwiIjKV3MaN5Ui62RkYGCAqKgovPnmm+jbty/MzMzwxx9/oEePHlKHRkSkGyYjADJKRgsWLCi1zs/PD3FxcejTpw8SExORmJgIQH3bcf7wlYiqN2YjQEbJ6OOPPy53m/Xr12P9+vWadSYjIqruBHMRABklo9TUVKlDICKqekxGAGSUjJycnKQOgYiIXhLZ/s4oNTUVv//+e6n1v//+O65evaq/gIiIXoiikkvNIJuW0fM+/vhjPHjwAP379y+xPjIyEtbW1oiOjtbpeHl5ecjLy9MqUxUUwMBItk8REckAx4zUZNsyOnToEHr16lVqfc+ePbF//36djzdv3jxYWVlpLXcPxpW/IxFRZbBhBEDGyejevXuwsLAotd7c3Bx37tzR+XhhYWG4f/++1mLbsWdVhEpEVAZmI0DGycjR0REJCQml1u/fvx+NGjXS+XhKpRKWlpZaC7voiOhlE4rKLTWFbJPRsGHD8J///AfffvstVCqVprywsBCLFy9GTEwM3n77bQkjJCIiXcn2q39YWBgOHDiAKVOmYO7cuXBzcwMAJCcn49atW+jWrZvmDrBERNVWDWrdVIZsW0ZKpRI7duzADz/8AF9fX9y+fRu3b9+Gr68vVq1ahV27dkGpVEodJhFROfQ7ZhQZGQlnZ2eYmJjAz88PR48eLXXb8+fPIygoCM7OzlAoFFi0aFGZx54/fz4UCgWmTJlS4bhk2zIC1BdKHT16NEaPHi11KEREL0aPLaOYmBiEhoZi2bJl8PPzw6JFixAYGIjk5GTY2dkV2z43NxcuLi4YPHhwuZdWO3bsGJYvXw4PD48Xik22LSMioppAnxMYFixYgLFjx2L06NFwd3fHsmXLULt2baxatarE7du1a4dvvvkGQ4cOLbOnKScnB8OHD8fKlSthY2NTsaD+n6xbRhkZGfjhhx9w8uRJ3L9/X2siA6C+UOrzd4IlIqpW9NQyys/Px4kTJxAWFqYpMzAwQEBAAA4dOlSpY0+cOBH9+vVDQEAA5syZ80LHkG0yOnPmDLp164bHjx/Dzc0NZ8+ehbu7O7Kzs3Hjxg00bdoUjRs3ljpMIqKXqqSrxyiVymItmdu3b6OwsBD29vZa5fb29rh48eILnz86OhonT57EsWPHXvgYgIy76aZNmwZzc3MkJydj165dEEJg8eLFuH79OmJiYnDv3j3Mnz9f6jCJiMpRuQkMJV09Zt68eXqJ/Pr165g8eTKioqJgYmJSqWPJtmWUkJCAqVOnwtHREXfv3gUATTfd4MGDceDAAXzyySfYu3evlGESEZWpsj9cDQsLQ2hoqFZZSeM7devWhaGhITIzM7XKMzMz4eDg8ELnPnHiBLKystC2bVtNWWFhIfbt24clS5YgLy8PhoaGOh1Lti0jlUqlaW5aW1vD0NBQk5QAoHXr1jhx4oRU4RER6aaSM7tLunpMScnI2NgY3t7eWuPoKpUKcXFx6NChwwuF3rNnT5w9e1Zzh+3ExET4+Phg+PDhSExM1DkRATJuGTVp0kRzwz0DAwM0adIEu3btwltvvQUAOHjwIKytrSWMkIioegkNDUVwcDB8fHzg6+uLRYsW4dGjR5qfx4wcORINGzbUdPPl5+cjKSlJ8/8bN24gMTER5ubmcHV1hYWFBVq1aqV1DjMzM9SpU6dYeXlkm4x69+6NX3/9FXPnzgUATJgwAf/4xz9w5coVCCEQHx+Pf/zjHxJHSURUDoX+fmg0ZMgQ3Lp1CzNnzkRGRgbatGmD2NhYTS9TWloaDAz+22GWnp4OLy8vzXpERAQiIiLg7++P+Pj4Ko1Ntslo+vTpGDZsGJ4+fYpatWphypQpePToETZs2ABDQ0N89tln+Oc//yl1mERE1UpISAhCQkJKrHs+wTg7O0MIUaHjv2iSkm0ysrGxgbe3t2ZdoVBgxowZmDFjhoRRERFVTE268nZlyHYCQ48ePcr8QeuePXvQo0cPPUZEREQvSrbJKD4+vtgUxWdlZWVxWjcRVX+8tx4AGXfTAequudKkpKSUeSdYIqJqQY8TGKozWSWjH3/8ET/++KNmfc6cOVi5cmWx7bKzs3HmzBm8+uqr+gyPiKjCKjY9oOaSVTLKzc3FrVu3NOsPHz7UmoYIqFtLZmZmeP/99zFz5kx9h0hERC9AVslowoQJmDBhAgD1j14XL16M119/XeKoiIgqgb10AGQ8geHHH38s8xIWt2/fxr59+/QYERHRC+AEBgAyTkbdu3fHzp07S62Pi4tD9+7d9RgRERG9KFl10z2rvF8FV+RqsUREkuFsOgAyS0ZpaWm4evWqZv3ixYsldsVlZ2dj+fLlcHJy0mN0REQVxyswqMkqGa1evRqzZ8+GQqGAQqHA3LlzNRdKfZYQAoaGhli+fLkEURIRUUXJKhm99dZbaNWqFYQQeOuttzBp0iR06dJFa5uiqd1t2rSBsbGxRJESEVFFyCoZtWjRAi1atACgbiV17doVTZo00domLy8PW7Zswfjx4xEbG4snT55IESoRkW7YTQdAZsnoWcHBwZr/CyEQFxeHqKgobNy4EQ8ePEC9evXw9ttvSxghEZEOmIwAyDgZAer7r0dFRSE6OhoZGRlQKBQYOnQoQkJC0L59+zKvXUdEVD3wcwqQYTK6cuUKoqKiEBUVhUuXLqFhw4YYPnw4fH19MWTIEAQFBb3w/dyJiPSOuQiAzJJRhw4dcPToUdStWxdvvvkmvv/+e3Tu3BkAcPnyZYmjIyKiFyWrZHTkyBE0adIECxYsQL9+/WBkJKvwiYiKY8sIgMwuB7RkyRLUr18fb7zxBhwcHDB+/Hjs2bOnwvdoJyKqLkQll5pCVsnogw8+wIEDB3D58mVMmTIF+/fvR8+ePdGwYUPMnDlT82NYIiLZ4IVSAcgsGRVp0qQJZsyYgaSkJBw7dgxDhw5FfHw8hBD44IMPMG7cOGzdupW/MSIikglZJqNneXt7Y8GCBbh+/Tp27NiBwMBAxMTE4PXXX0fdunWlDo+IqGwKReWWGkL2yaiIgYEBAgICsGbNGmRmZuI///kPevbsKXVYRESkgxqTjJ5lYmKCIUOGYPPmzVKHQkRUNo4ZAaihyYiIiOSFP9QhIpJSDWrdVAaTERGRlJiMALCbjoiIqgEmIyIikhy76YiIpMRuOgBMRkREkuIlzNTYTUdERJJjy4iISEpsGAFgMiIikhaTEQAmozKJUw+kDgH1etWROgTkNLOVOgQcPZIvdQgAAJd6xlKHABdHQ6lDwMwVj6UOAQDg1d5E6hCoinDMiIiIJMeWERGRhDiZTo0tIyIikhxbRkREUmLLCACTERGRtJiMALCbjoiIqgG2jIiIJMSGkZqsk9HDhw+RnZ2Nxo0ba8rS09OxbNky5OXlISgoCL6+vhJGSERUDk6nAyDzZDRu3Dikpqbi8OHDAIAHDx6gffv2+Pvvv2FgYIDFixcjNjYW3bp1kzZQIqJSMBepyXrM6MCBA3jttdc062vXrkV6ejoOHjyIe/fuwcPDA3PmzJEwQiIi0oWsk9Ht27fRsGFDzfqWLVvQuXNntG/fHhYWFhg5ciROnz4tYYREROVQVHKpIWSdjKytrZGRkQEAePz4Mfbv34/evXtr6o2MjJCbmytVeEREpCNZjxl17NgR//73v9G8eXPExsbiyZMnGDBggKb+r7/+0mo5ERFVNzWocVMpsk5G8+fPR2BgIIKCggAA//jHP9CyZUsAQGFhIX799Vf06dNHyhCJiMrGbARA5smoWbNmSE5ORlJSEqysrODs7Kypy83NxZIlS+Dp6SldgERE5eBsOjXZjhnl5uZi0KBB+OWXX+Dp6amViADAwsICAwYMKFZORPS/LDIyEs7OzjAxMYGfnx+OHj1a6rbnz59HUFAQnJ2doVAosGjRomLbLF26FB4eHrC0tISlpSU6dOiA7du3Vzgu2Saj2rVrY9euXZygQESyplBUbqmImJgYhIaGIjw8HCdPnoSnpycCAwORlZVV4va5ublwcXHB/Pnz4eDgUOI2jRo1wvz583HixAkcP34cPXr0wIABA3D+/PkKxSbbZAQAnTt3xqFDh6QOg4hIFhYsWICxY8di9OjRcHd3x7Jly1C7dm2sWrWqxO3btWuHb775BkOHDoVSqSxxm/79++PVV19Fs2bN8Morr2Du3LkwNzfXXIxAV7JORkuWLMH+/fsxY8YM/P3331KHQ0Skd3l5eXjw4IHWkpeXV2y7/Px8nDhxAgEBAZoyAwMDBAQEVNmX+sLCQkRHR+PRo0fo0KFDhfaVdTLy9PTE33//jXnz5sHJyQlKpVLTb1m0WFlZSR0mEVGpKttNN2/ePFhZWWkt8+bNK3ae27dvo7CwEPb29lrl9vb2mt9rvqizZ8/C3NwcSqUS77//PjZu3Ah3d/cKHUPWs+mCgoKg4FQUIpKzSn6EhYWFITQ0VKustC61l8XNzQ2JiYm4f/8+1q9fj+DgYOzdu7dCCUnWyWjNmjVSh0BEVCmKSmYjpVKpU/KpW7cuDA0NkZmZqVWemZlZ6uQEXRkbG8PV1RUA4O3tjWPHjmHx4sVYvny5zseQdTcdEZHs6enadMbGxvD29kZcXJymTKVSIS4ursLjO+VRqVQljluVRfbJKC0tDe+//z7c3NxgY2ODffv2AVD3j06aNAmnTp2SOEIiouohNDQUK1euxI8//ogLFy5gwoQJePToEUaPHg0AGDlyJMLCwjTb5+fnIzExEYmJicjPz8eNGzeQmJiIlJQUzTZhYWHYt28frl69irNnzyIsLAzx8fEYPnx4hWKTdTddUlISunTpApVKBT8/P6SkpKCgoACAukl64MABPHr0CD/88IPEkRIRlUyfo95DhgzBrVu3MHPmTGRkZKBNmzaIjY3VTGpIS0uDgcF/2yjp6enw8vLSrEdERCAiIgL+/v6Ij48HAGRlZWHkyJG4efMmrKys4OHhgT///BO9evWqUGyyTkZTp06FtbU1Dh8+DIVCATs7O636fv36ISYmRqLoiIjKp+85WCEhIQgJCSmxrijBFHF2doYQoszjVdWXfVl30+3btw8TJkxAvXr1SpxV5+joiBs3bkgQGRGRjng/IwAybxmpVCrUrl271Ppbt27pfYojEVFF1KB8Uimybhm1bdsWf/zxR4l1BQUFiI6ORvv27fUcFRFRBbBlBEDmySgsLAyxsbGYMGECzp07B0A9Z37Xrl3o3bs3Lly4gGnTpkkcJRERlUfW3XR9+/bFmjVrMHnyZKxYsQIA8M4770AIAUtLS/z000/o2rWrxFESEZWuBjVuKkXWyQgARowYgUGDBmHHjh1ISUmBSqVC06ZNERgYCAsLC6nDIyIqE69opib7ZAQAZmZmeOONN6QOg4io4piMAMgsGaWlpb3Qfo6OjlUcCRFR1WAuUpNVMiq69W1FFRYWvoRoiIgqj910arJKRqtWrdJKRiqVCosXL8a1a9cwfPhwuLm5AQAuXryIdevWwdnZGZMmTZIqXCIi0pGsktGoUaO01ufOnYsnT54gJSUFderU0aqbNWsWOnfuXOmbRhER0csn698ZLVu2DOPGjSuWiACgXr16GDt2LJYuXSpBZEREuqnsnV5rClm1jJ53584d5Obmllqfm5uLO3fu6DEiIqIKqkEJpTJk3TJq3749Fi1ahBMnThSrO378OBYvXgw/Pz8JIiMi0o2ikv9qClm3jJYsWYJu3brB19cX7du3R7NmzQAAly5dwuHDh2Fra4vvvvtO4iiJiEpXk7raKkPWLSN3d3ecPXsWkyZNwp07dxATE4OYmBjcuXMHkydPxtmzZ9GyZUupwyQionLIumUEAPb29li4cCEWLlwodShERPSCZJ+MiIjkjN10arJPRhcuXMDq1atx5coV3Lt3r9gtchUKBeLi4iSKjoiobMxFarJORj///DNGjx6NWrVqwc3NDTY2NsW2Ke/+7UREkmI2AiDzZDRr1ix4eXlh+/btqFu3rtThEBFVGLvp1GQ9my49PR3vvvsuExERkczJumXk4eGB9PR0qcMgInphbBipybpltGDBAvzwww84ePBgpY+Vl5eHBw8eaC2qwoIqiJKIqAyKSi41hKxbRl999RWsrKzQpUsXuLu7w9HREYaGhlrbKBQKbN68udxjzZs3D7Nnz9Yqs3XtirrNulVlyEREWmpQPqkUWSejM2fOQKFQwNHRETk5OUhKSiq2ja434wsLC0NoaKhWmffgr6okTiKi0nACg5qsk9HVq1er7FhKpRJKpVKrzMBQ1k8PEckBkxEAmY8ZERFRzVBjvvo/fPgQ9+/fh0qlKlbn6OgoQUREROVjw0hN9slo6dKlWLBgAa5cuVLqNoWFhXqMiIhIdxwzUpN1N92yZcswceJEuLq6Ys6cORBCYMqUKZg2bRocHBzg6emJH374QeowiYjKwLndgMyT0XfffYfAwEBs374d48aNAwD069cPc+fORVJSEh4+fMjbjhNRtaZQVG6pKWSdjC5fvoz+/fsDAGrVqgUAyM/PBwBYWVlhzJgx+Pe//y1ZfERE5WLDCIDMk5GVlRUKCtRXSbC0tETt2rVx/fp1Tb2FhQUyMjKkCo+IiHQk62TUqlUrnD59WrPevn17LF26FDdu3MD169exfPlyvPLKKxJGSERUNjaM1GQ9m+6dd97BsmXLkJeXB6VSidmzZyMgIEAzlbtWrVrYsGGDxFESEZWuJo37VIask9Ho0aMxevRozXqnTp1w/vx5/P777zA0NETv3r3ZMiIikgFZJ6O0tDTUq1cPpqammjIXFxdMnjwZAPD48WOkpaXxR69EVG2xZaQm6zGjJk2aYOPGjaXWb9myBU2aNNFjREREFcMxIzVZJyMhRJn1T58+hYGBrB8iEdH/BNl10z148ADZ2dma9Tt37iAtLa3YdtnZ2YiOjkb9+vX1GB0RUQXVpOZNJcguGS1cuBCff/45APW9iqZMmYIpU6aUuK0QAnPmzNFjdEREFcMxIzXZJaPevXvD3NwcQghMnToVw4YNQ9u2bbW2USgUMDMzg7e3N3x8fCSKlIiofMxFarJLRh06dECHDh0AAI8ePcKgQYPQunVriaMiInpBzEYAZJiMnhUeHl5ieX5+Pp4+fQozMzM9R0REVDHMRWqynmoWHR2Njz76SKts9uzZMDc3h7W1Nd544w3k5ORIFB0REelK1snoX//6Fx49eqRZP3jwIGbPno3AwEB89NFHiI2Nxdy5cyWMkIiobLyFhJqsu+kuX76M4OBgzfq6devg4OCAjRs3wsjICCqVChs2bMC8efMkjJKIqAw1KaNUgqxbRnl5eTAxMdGs79ixA3379oWRkTrHuru74++//5YqPCKicvEKDGqyTkZNmjTBrl27AADHjx9HSkoK+vTpo6nPzMyEubm5VOEREZWP2QiAzJPR+PHj8csvv8DDwwO9e/dGo0aN8Nprr2nqExIS0LJlSwkjJCIqm75zUWRkJJydnWFiYgI/Pz8cPXq01G3Pnz+PoKAgODs7Q6FQYNGiRcW2mTdvHtq1awcLCwvY2dlh4MCBSE5OrnBcsk5GH374IZYvX46mTZtiwIAB2LFjh+YK3nfv3kVGRgaGDx8ucZRERNVDTEwMQkNDER4ejpMnT8LT0xOBgYHIysoqcfvc3Fy4uLhg/vz5cHBwKHGbvXv3YuLEiTh8+DB27tyJp0+fonfv3lqTy3Qh6wkMADB27FiMHTu2WLmtrS2OHz8uQURERLrT5/yFBQsWYOzYsZr7wC1btgx//PEHVq1ahWnTphXbvl27dmjXrh0AlFgPALGxsVrra9asgZ2dHU6cOIGuXbvqHJusW0YTJkzAwYMHpQ6DiOjF6amfLj8/HydOnEBAQICmzMDAAAEBATh06FBVPBIAwP379wGoGwQVIetktG7dOnTp0gVNmzZFeHg4Ll26JHVIREQVUtlclJeXhwcPHmgteXl5xc5z+/ZtFBYWwt7eXqvc3t4eGRkZVfJYVCoVpkyZgk6dOqFVq1YV2lfWySgrKwvR0dFo1aoV5s+fj+bNm8PPzw+RkZG4ffu21OEREZWrsj96nTdvHqysrLQWqX5bOXHiRJw7dw7R0dEV3lfWyUipVGLw4MHYvHkzMjIy8O9//xtKpRKTJk1Cw4YN8dprr+GXX37BkydPpA6ViOilCAsLw/3797WWsLCwYtvVrVsXhoaGyMzM1CrPzMwsdXJCRYSEhGDr1q3Ys2cPGjVqVOH9ZZ2MnmVjY4Px48dj3759SE1NxcCBA7Ft2zYMGzYMDg4OGDNmDM6cOSN1mEREVUqpVMLS0lJrUSqVxbYzNjaGt7c34uLiNGUqlQpxcXGaOyG8CCEEQkJCsHHjRuzevRtNmjR5oePIfjbds65fv46oqChERUXh/PnzqFOnDoYMGQJjY2OsXbsWa9aswXfffYcJEyZIHSoREQD9zqYLDQ1FcHAwfHx84Ovri0WLFuHRo0ea2XUjR45Ew4YNNd18+fn5SEpK0vz/xo0bSExMhLm5OVxdXQGou+bWrVuHzZs3w8LCQjP+ZGVlpfmpjS5kn4yys7Pxyy+/ICoqCgkJCTAyMkK/fv3wxRdfoF+/fqhVqxYAdb/qsGHD8PnnnzMZEVG1oc9kNGTIENy6dQszZ85ERkYG2rRpg9jYWM2khrS0NBgY/LfDLD09HV5eXpr1iIgIREREwN/fH/Hx8QCApUuXAgC6deumda7Vq1dj1KhROscm62T0xhtvYPv27cjPz4efnx++++47DB06FDY2NsW2VSqVePPNN7Fp0yb9B0pEVE2EhIQgJCSkxLqiBFPE2dkZQogyj1deva5knYwSExPxySefYOTIkWjWrFm52/fq1Qt79uzRQ2RERLrhRbvVZJ2MUlNTtdYLCgpw6dIl5OTkoEWLFsUuklqvXj34+/vrM0QiojIxF6nJcjbdtm3bMGLECLz77rvYvXs3AGDTpk1wdnZGq1at0L59e9SrVw8zZsyQOFIiItKF7FpGsbGxeO2111CrVi2Ympri559/xqpVq/Dee+/B3d0dgwcPRkFBAf7880/MmzcPTk5OJV67joioWmDTCIAMk9HXX3+NVq1aYd++fbC2tsb777+P8ePHo1evXti6dSsU/98BW1BQgPbt22PZsmVMRkRUbXHMSE123XTnz5/HqFGjYG1tDQCYNGkSnjx5gnfeeUeTiADAyMgIw4cPx8WLFyWKlIiofLy3nprsWka3bt3SutCfnZ0dABS7+F9RHS8FRETVGptGAGSYjABotYAU/EMSkYzxE0xNlsno6tWrOHnyJID/3jvj0qVLmq67Is9P/SYioupJlsnos88+w2effaZV9sEHHxTbTgjBlhMRVWv8iFKTXTJavXq11CEQEVUZJiM12SWj4OBgqUMgIqIqJrtkRERUk7BlpMZkREQkIeYiNSajMjx1t5A6BDS2rJrLs1eG0ZMCqUNAbVsTqUMAAJxNk/7v8ffy61KHgK++d5Q6BABA1Anp/x5UNZiMiIikxKYRACYjIiJJMRepMRkREUmIExjUmIyIiCTEZKQmu6t2ExFRzcNkREREkmM3HRGRhNhNp8ZkREQkIeYitRqXjHJzcxEdHY28vDy8+uqrcHJykjokIqJSsWWkJutk9N577+HIkSM4d+4cACA/Px/t27fXrFtZWWH37t3w8vKSMkwiolIxGanJegLDnj17MGjQIM36unXrcO7cOURFReHcuXNwcHDA7NmzJYyQiIh0IetklJGRAWdnZ836pk2b4OPjg2HDhsHd3R1jx47FkSNHpAuQiIh0IutkZGZmhuzsbABAQUEB4uPjERgYqKm3sLDQ3JaciKg6Uigqt9QUsh4zatu2LVauXInu3btjy5YtePjwIfr376+pv3z5Muzt7SWMkIiobDUon1SKrJPR3Llz0bt3b/j4+EAIgTfffBO+vr6a+o0bN6JTp04SRkhEVLaa1LqpDFknIx8fHyQnJ+PgwYOwtraGv7+/pi47OxsffPCBVhkRUXXDXKQm22T0+PFjTJ8+Hd27d8eAAQOK1VtbW2Py5MkSREZEVAHMRgBkPIHB1NQUy5cvR2ZmptShEBFRJcm2ZQQA3t7emh+4EhHJEceM1GTbMgKARYsWITo6Gt9//z0KCgqkDoeIqMIUlVxqClm3jEaNGgUDAwOMHz8ekyZNQsOGDWFqaqq1jUKhwOnTpyWKkIiobGwZqck6Gdna2qJOnTpwc3OTOhQiohfCXKQm62QUHx8vdQhERJXClpGarMeMiIioZpB9Mnrw4AHmz5+PwMBAeHl54ejRowCAu3fvYsGCBUhJSZE4QiKi0nECg5qsu+n+/vtv+Pv74/r162jWrBkuXryInJwcAOrxpOXLl+PatWtYvHixxJESEZWM3XRqsk5Gn3zyCR4+fIjExETY2dnBzs5Oq37gwIHYunWrRNEREemAyQiAzLvpduzYgUmTJsHd3R2KEr5euLi44Pr16xJERkSkG3bTqcm6ZfT48WPUq1ev1PqHDx/qMRoioopjN52arFtG7u7u2LdvX6n1mzZtgpeXlx4jIiKiFyHrZDRlyhRER0fjq6++0tzRVaVSISUlBSNGjMChQ4fw0UcfSRwlEVHp2E2nJutuunfeeQfXrl3DjBkzMH36dABAnz59IISAgYEBvvzySwwcOFDaIImIysBuOjVZJyMAmD59OkaMGIENGzYgJSUFKpUKTZs2xaBBg+Di4iJ1eEREZWIuUpN1MkpLS0O9evXg6OhYYnfc48ePcevWLTg6OkoQHRFR+dgyUpP1mFGTJk2wcePGUuu3bNmCJk2a6DEiIqKKUSgqt9QUsk5GQogy658+fQoDA1k/RCKi/wmy+6R+8OAB0tLSkJaWBgC4c+eOZv3Z5cyZM4iOjkb9+vUljpiIqHT6nk0XGRkJZ2dnmJiYwM/PT3M9z5KcP38eQUFBcHZ2hkKhwKJFi4pts2/fPvTv3x8NGjSAQqHApk2bXiAqGSajhQsXokmTJmjSpAkUCgWmTJmiWX928fLywrZt2/D+++9LHTIRUan02U0XExOD0NBQhIeH4+TJk/D09ERgYCCysrJK3D43NxcuLi6YP38+HBwcStzm0aNH8PT0RGRkZEUfuhbZTWDo3bs3zM3NIYTA1KlTMWzYMLRt21ZrG4VCATMzM3h7e8PHx0eiSImIyqfPYZ8FCxZg7NixGD16NABg2bJl+OOPP7Bq1SpMmzat2Pbt2rVDu3btAKDEegDo27cv+vbtW+nYZJeMOnTogA4dOgBQZ+SgoCC0atVK4qiIiF5MZSch5OXlIS8vT6tMqVRCqVRqleXn5+PEiRMICwvTlBkYGCAgIACHDh2qXBBVQHbddEVyc3Px7bffYvv27VKHQkT0wio7ZjRv3jxYWVlpLfPmzSt2ntu3b6OwsBD29vZa5fb29sjIyHhZD09nsmsZFalduzaMjIxgZmYmdShERJIJCwtDaGioVtnzrSI5kG3LCACCgoKwfv36cqd4ExFVV5WdwKBUKmFpaam1lJSM6tatC0NDQ2RmZmqVZ2Zmljo5QZ9knYyGDh2KrKwsdO/eHVFRUUhISMDJkyeLLURE1ZW+pnYbGxvD29sbcXFxmjKVSoW4uDjNOLyUZNtNBwDdunXT/H///v3F6oUQUCgUKCws1GNURES60+dVFEJDQxEcHAwfHx/4+vpi0aJFePTokWZ23ciRI9GwYUPNmFN+fj6SkpI0/79x4wYSExNhbm4OV1dXAEBOTg5SUlI050hNTUViYiJsbW0rdCk2WSej1atXSx0CEVGl6HNq95AhQ3Dr1i3MnDkTGRkZaNOmDWJjYzWTGtLS0rSuWpOenq51T7iIiAhERETA398f8fHxAIDjx4+je/fumm2Kxq+Cg4OxZs0anWOTdTIKDg6WOgQiokrR9/XlQkJCEBISUmJdUYIp4uzsXO6YfLdu3apk3F7WyehZOTk5uH79OgCgcePGMDc3lzgiIiLSlawnMADAsWPH0L17d9jY2KBVq1Zo1aoVbGxs0KNHDxw/flzq8IiIysSrdqvJumV05MgRdOvWDcbGxhgzZgxatGgBALhw4QL+85//oGvXroiPj4evr2+5xyrpV8yioAAKI1k/RURUzdWgfFIpsv6knT59Oho2bIgDBw4Umyc/a9YsdOrUCdOnT8fOnTvLPda8efMwe/ZsrTLrDr1g07F3lcZMRPQsRU1q3lSCrLvpjhw5gvHjx5f4gy17e3uMGzcOhw8f1ulYYWFhuH//vtZi7dujqkMmItKi71tIVFeybhkZGBigoKCg1PrCwkKdb65X0oUF2UVHRC8bG0Zqsm4ZdezYEZGRkbh27VqxurS0NPz73/9Gp06dJIiMiIgqQtZf/b/88kt07doVzZs3xxtvvIFXXnkFAJCcnIzNmzfDyMioxKvXEhFVF2wYqck6GXl5eeHIkSOYPn06tmzZgtzcXADqK3r36dMHc+bMgbu7u8RREhGVzoDZCIDMkxEAuLu7Y+PGjVCpVLh16xYAoF69ejqPFRERSYm5SE32yaiIQqHQTJHkVEkikgt+XKnJvvmQlJSEN998E5aWlqhfvz7q168PS0tLvPnmmzh37pzU4RERlYlTu9Vk3TLav38/+vbtC5VKhQEDBmhNYNiyZQu2b9+O2NhYdOnSReJIiYioLLJORh999BHs7Oywd+9eNG7cWKvu+vXr6Nq1K0JDQ3Hs2DGJIiQiKhu76dRk3U13/vx5fPDBB8USEaC+cveECRNw/vx5CSIjItINu+nUZN0ycnJyKnZx02fl5+eXmKiIiKoLtozUZN0ymjlzJr799lskJiYWqzt16hS+++47zJo1S+9xERHpii0jNVm3jA4fPgx7e3t4e3ujY8eOmnuyX7p0CYcOHUKrVq1w6NAhHDp0SLOPQqHA4sWLpQqZiEgLf/SqJutktGTJEs3/ExISkJCQoFV/9uxZnD17VquMyYiIqPqRdTJSqVRSh0BEVClsGKnJOhkREckdJzCo1YhkdO7cOWzbtg1Xr14FADg7O6Nv375o3bq1tIEREZWDuUhN1skoLy8P48ePx88//wwhhObiqCqVCmFhYRg+fDi+//57GBsbSxwpEVHJ2DJSk/XU7k8//RQ//fQTJkyYgAsXLuDJkyfIy8vDhQsX8P7772Pt2rWYOnWq1GESEVE5ZN0yWrt2LUaMGKE1qw4A3NzcEBkZiQcPHmDt2rVYtGiRNAESEZWDDSM1WbeMnj59ivbt25da37FjRxQUFOgxIiKiilEoKrfUFLJORoGBgfjzzz9LrY+NjUXv3r31GBERUcUwGanJupvuiy++wFtvvYVBgwZh4sSJWldgiIyMxLVr1xATE4O7d+9q7WdraytFuERExci6RVCFZJ2MWrRoAUB9pYXNmzdr1QkhAKhvS/68wsLClx8cEZEOalLrpjJknYxmzpzJW4wTEdUAsk5GvCI3Eckdv06ryToZERHJHTt31GSdjD7//PNyt1EoFPjss8/0EA0RUcUxF6nJOhmV1U2nUCgghGAyIqJqjS0jNVnPKlSpVMWWgoICXL58GR999BF8fHyQlZUldZhERKXinV7VZJ2MSmJgYIAmTZogIiICzZo1w4cffih1SEREVI4al4ye1bVrV2zbtk3qMIiISsUrMKjJesyoPMePH9fcVoKIqDqqQfmkUmSdjH766acSy7Ozs7Fv3z789ttvGDNmjJ6jIiLSXU1q3VSGrJPRqFGjSq2rW7cupk2bhpkzZ+ovICKiCmLfjZqsk1FqamqxMoVCARsbG1hYWEgQERFRxbBlpCbrZOTk5KS1fvHiRfz666+4efMmmjdvjlGjRsHS0lKi6IiISFeyS0ZLlizBt99+i4MHD6Ju3bqa8t9//x2DBw9Gfn6+puzbb7/F4cOHtbYjIqpO2DBSk1135ZYtW9C0aVOtBFNQUIAxY8bA0NAQq1evxtmzZzF//nxcu3YNc+fOlTBaIqKycWq3muySUVJSUrFbje/Zswe3bt3CRx99hODgYLRs2RJTp07FW2+9xd8ZEVG1xiswqMkuGd25cweNGzfWKouLi4NCocAbb7yhVd6pUyekpaXpMzwiogphy0hNdmNG9vb2yMjI0Crbv38/ateuDU9PT61yY2NjGBsb6zM8IqIKqUkJpTJk1zLy8fHBjz/+iIcPHwIAzp8/j6NHjyIwMBBGRtq59eLFi2jUqJEUYRIRUQXIrmUUHh6Odu3aoVmzZmjZsiVOnDgBhUKBsLCwYttu3LgRPXr0kCBKIiLdsGGkJruWUevWrbF79254e3sjPT0d7du3x7Zt2+Dt7a21XXx8PGrXro3BgwdLFCkRUfk4ZqQmu2QEAB07dsQff/yBCxcuIDY2FgEBAcW26datG86ePYvevXtLECERkW4MKrlUVGRkJJydnWFiYgI/Pz8cPXq01G3Pnz+PoKAgODs7Q6FQYNGiRZU+ZmlkmYyIiGoKfbaMYmJiEBoaivDwcJw8eRKenp4IDAws9Sakubm5cHFxwfz58+Hg4FAlxywNkxERkYQUEJVaKmLBggUYO3YsRo8eDXd3dyxbtgy1a9fGqlWrSty+Xbt2+OabbzB06FAolcoqOWZpmIyIiP4H5Ofn48SJE1rDGgYGBggICMChQ4ckP6bsZtMREdUklZ2EkJeXh7y8PK0ypVJZrCVz+/ZtFBYWwt7eXqvc3t4eFy9efKFzV+kxBb0UT548EeHh4eLJkyf/0zFUlzgYQ/WKgzFUnfDwcAFAawkPDy+23Y0bNwQAcfDgQa3yTz75RPj6+pZ7HicnJ7Fw4cIqPeazFEKIinU6kk4ePHgAKysr3L9/X7LbWFSHGKpLHIyhesXBGKqOri2j/Px81K5dG+vXr8fAgQM15cHBwcjOzsbmzZvLPI+zszOmTJmCKVOmVNkxn8UxIyIiGVMqlbC0tNRaSppsYGxsDG9vb8TFxWnKVCoV4uLi0KFDhxc6d1Uek2NGRET/I0JDQxEcHAwfHx/4+vpi0aJFePToEUaPHg0AGDlyJBo2bIh58+YBULd8kpKSNP+/ceMGEhMTYW5uDldXV52OqSsmIyKi/xFDhgzBrVu3MHPmTGRkZKBNmzaIjY3VTEBIS0uDgcF/O8zS09Ph5eWlWY+IiEBERAT8/f0RHx+v0zF1xWT0kiiVSoSHh5c6N/9/JYbqEgdjqF5xMAbphISEICQkpMS6ogRTxNnZGbpMKyjrmLriBAYiIpIcJzAQEZHkmIyIiEhyTEZERCQ5JqOXpCouqV4Z+/btQ//+/dGgQQMoFAps2rRJr+efN28e2rVrBwsLC9jZ2WHgwIFITk7WawwAsHTpUnh4eGh+f9GhQwds375d73E8a/78+VAoFFo/HnzZZs2aBYVCobU0b95cb+cvcuPGDbzzzjuoU6cOTE1N0bp1axw/flyvMRTdDuH5ZeLEiXqNg7QxGb0EVXVJ9cp49OgRPD09ERkZqbdzPmvv3r2YOHEiDh8+jJ07d+Lp06fo3bs3Hj16pNc4GjVqhPnz5+PEiRM4fvw4evTogQEDBuD8+fN6jaPIsWPHsHz5cnh4eOj93C1btsTNmzc1y4EDB/R6/nv37qFTp06oVasWtm/fjqSkJPzrX/+CjY2NXuM4duyY1vOwc+dOAOCNOKVWoYsHkU58fX3FxIkTNeuFhYWiQYMGYt68eZLEA0Bs3LhRknMXycrKEgDE3r17JY1DCCFsbGzE999/r/fzPnz4UDRr1kzs3LlT+Pv7i8mTJ+vt3OHh4cLT01Nv5yvJp59+Kjp37ixpDCWZPHmyaNq0qVCpVFKH8j+NLaMq9jIu014T3L9/HwBga2srWQyFhYWIjo7Go0ePXvjyJ5UxceJE9OvXr8Q7E+vDpUuX0KBBA7i4uGD48OFIS0vT6/m3bNkCHx8fDB48GHZ2dvDy8sLKlSv1GsPz8vPzsXbtWrz77rtQ1KR7eMsQk1EVK+uS6hkZGRJFJS2VSoUpU6agU6dOaNWqld7Pf/bsWZibm0OpVOL999/Hxo0b4e7urtcYoqOjcfLkSc1lVvTNz88Pa9asQWxsLJYuXYrU1FR06dIFDx8+1FsMV65cwdKlS9GsWTP8+eefmDBhAiZNmoQff/xRbzE8b9OmTcjOzsaoUaMki4HUeAUGeukmTpyIc+fO6X2MooibmxsSExNx//59rF+/HsHBwdi7d6/eEtL169cxefJk7Ny5EyYmJno55/P69u2r+b+Hhwf8/Pzg5OSEX375Be+9955eYlCpVPDx8cGXX34JAPDy8sK5c+ewbNkyBAcH6yWG5/3www/o27cvGjRoIMn56b/YMqpidevWhaGhITIzM7XKMzMzS72HfE0WEhKCrVu3Ys+ePWjUqJEkMRgbG8PV1RXe3t6YN28ePD09sXjxYr2d/8SJE8jKykLbtm1hZGQEIyMj7N27F99++y2MjIxQWFiot1iKWFtb45VXXkFKSorezlm/fv1iXwBatGih9+7CIteuXcOuXbswZswYSc5P2piMqtjLuEy7HAkhEBISgo0bN2L37t1o0qSJ1CFpqFSqYvd/eZl69uyJs2fPIjExUbP4+Phg+PDhSExMhKGhod5iKZKTk4PLly+jfv36ejtnp06dik3v/+uvv+Dk5KS3GJ61evVq2NnZoV+/fpKcn7Sxm+4lqKpLqldGTk6O1rfe1NRUJCYmwtbWFo6Oji/9/BMnTsS6deuwefNmWFhYaMbLrKysYGpq+tLPXyQsLAx9+/aFo6MjHj58iHXr1iE+Ph5//vmn3mKwsLAoNlZmZmaGOnXq6G0M7eOPP0b//v3h5OSE9PR0hIeHw9DQEMOGDdPL+QHgo48+QseOHfHll1/irbfewtGjR7FixQqsWLFCbzEUUalUWL16NYKDg2FkxI/BakHq6Xw11XfffSccHR2FsbGx8PX1FYcPH9br+ffs2VPsVsQARHBwsF7OX9K5AYjVq1fr5fxF3n33XeHk5CSMjY1FvXr1RM+ePcWOHTv0GkNJ9D21e8iQIaJ+/frC2NhYNGzYUAwZMkSkpKTo7fxFfv/9d9GqVSuhVCpF8+bNxYoVK/QegxBC/PnnnwKASE5OluT8VByv2k1ERJLjmBEREUmOyYiIiCTHZERERJJjMiIiIskxGRERkeSYjIiISHJMRkREJDkmIyIikhyTEZEexcfHQ6FQIDs7W+pQiKoVJiOShVu3bmHChAlwdHSEUqmEg4MDAgMDkZCQAABQKBTYtGlTlZzr6tWrUCgUSExMrJLjPatjx464efMmrKysqvzYRHLGKwSSLAQFBSE/Px8//vgjXFxckJmZibi4ONy5c0fnY+Tn58PY2PglRlk+Y2Pj/8lbiRCVS+qL4xGV5969ewKAiI+PL7HeyclJ62KsTk5OQgghwsPDhaenp1i5cqVwdnYWCoVCCCHE9u3bRadOnYSVlZWwtbUV/fr107poKJ67uKu/v7+mbuXKlaJ58+ZCqVQKNzc3ERkZqRVLQkKC8PT0FEqlUnh7e4uNGzcKAOLUqVNCiP9ewPbevXuaffbv3y86d+4sTExMRKNGjcSHH34ocnJyNPWRkZHC1dVVKJVKYWdnJ4KCgirxbBJVT0xGVO09ffpUmJubiylTpognT54Uq8/KytJcEfzmzZsiKytLCKFORmZmZqJPnz7i5MmT4vTp00IIIdavXy82bNggLl26JE6dOiX69+8vWrduLQoLC4UQQhw9elQAELt27RI3b94Ud+7cEUIIsXbtWlG/fn2xYcMGceXKFbFhwwZha2sr1qxZI4QQ4v79+8LW1la888474vz582Lbtm3ilVdeKTMZpaSkCDMzM7Fw4ULx119/iYSEBOHl5SVGjRolhBDi2LFjwtDQUKxbt05cvXpVnDx5UixevPilPddEUmEyIllYv369sLGxESYmJqJjx44iLCxMk1yEULdmNm7cqLVPeHi4qFWrliY5lebWrVsCgDh79qwQQojU1FStBFKkadOmYt26dVplX3zxhejQoYMQQoilS5eKOnXqiMePH2vqV65cWWYyeu+998S4ceO0jrl//35hYGAgHj9+LDZs2CAsLS3FgwcPynwMRHLHCQwkC0FBQUhPT8eWLVvQp08fxMfHo23btlizZk2Z+zk5OaFevXpaZZcuXcKwYcPg4uICS0tLODs7A0CZt79+9OgRLl++jPfeew/m5uaaZc6cObh8+TIAIDk5GR4eHjAxMdHs5+vrW2Z8p0+fxpo1a7SOGRgYCJVKhdTUVPTq1QtOTk5wcXHBiBEjEBUVhdzc3DKPSSRHnMBAsmFiYoJevXqhV69e+OyzzzBmzBiEh4dj1KhRpe5jZmZWrKzojqcrV65EgwYNoFKp0KpVK+Tn55d6nJycHADAypUr4efnp1VXmduG5+TkYPz48Zg0aVKxOkdHRxgbG+PkyZOIj4/Hjh07MHPmTMyaNQvHjh2DtbX1C5+XqLphMiLZcnd310znrlWrFgoLC8vd586dO0hOTsbKlSvRpUsXAMCBAwe0timacffs8ezt7dGgQQNcuXIFw4cPL/HYbm5uWLt2LfLy8qBUKgEAx44dKzOetm3bIikpCa6urqVuY2RkhICAAAQEBCA8PBzW1tbYvXs3Bg0aVO7jJZILJiOq9u7cuYPBgwfj3XffhYeHBywsLHD8+HF8/fXXGDBgAADA2dkZcXFx6NSpE5RKJWxsbEo8lo2NDerUqYMVK1agfv36SEtLw7Rp07S2sbOzg6mpKWJjY9GoUSOYmJjAysoKs2fPxqRJk2BlZYU+ffogLy8Px48fx7179xAaGoq3334b06dPx7hx4zBt2jSkpaUhIiICgPp3UCX59NNP0b59e4SEhGDMmDEwMzNDUlISdu7ciSVLlmDr1q24cuUKunbtChsbG2zbtg0qlQpubm5V+AwTVQNSD1oRlefJkydi2rRpom3btsLKykrUrl1buLm5iRkzZojc3FwhhBBbtmwRrq6uwsjIqNjU7uft3LlTtGjRQiiVSuHh4SHi4+OLTYBYuXKlaNy4sTAwMNCa2h0VFSXatGkjjI2NhY2Njejatav47bffNPUJCQnCw8NDGBsbC29vb7Fu3ToBQFy8eFEIUfLU7qNHj4pevXoJc3NzYWZmJjw8PMTcuXOFEOrJDP7+/sLGxkaYmpoKDw8PERMTUzVPLFE1ohBCCInzIVGNFRUVhdGjR+P+/fswNTWVOhyiaovddERV6KeffoKLiwsaNmyI06dP49NPP8Vbb73FRERUDiYjoiqUkZGBmTNnIiMjA/Xr18fgwYMxd+5cqcMiqvbYTUdERJLjj16JiEhyTEZERCQ5JiMiIpIckxEREUmOyYiIiCTHZERERJJjMiIiIskxGRERkeSYjIiISHL/B5dk1YfBuMMjAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "data_2d = np.vstack([ms_0, ms_1, ms_2])\n",
    "\n",
    "\n",
    "plt.figure(figsize=(4, 4))  # Adjust the size as needed\n",
    "sns.heatmap(data_2d, cmap=\"crest\", vmin=0.1, vmax=0.15, yticklabels=[\"Attackers\", \"Bystanders\", \"Supporters\"])  # Choose a colormap that fits your data\n",
    "# viridis, , annot=True\n",
    "# Optional: Add labels, title, etc.\n",
    "plt.title(\"Distribution of Users' Strategies within Different Groups\", size=10)\n",
    "plt.xlabel(\"Strategies\", size=10)#\n",
    "#plt.ylabel(\"Row\")\n",
    "plt.tick_params(axis='y', labelsize=12)\n",
    "\n",
    "# Display the heatmap\n",
    "plt.tight_layout()\n",
    "\n",
    "# Display the heatmap\n",
    "plt.savefig('../result/heatmap_muyixiao.png', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5987bb8",
   "metadata": {},
   "source": [
    "## draw tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d97d485",
   "metadata": {},
   "outputs": [],
   "source": [
    "max_level = []\n",
    "max_width = []\n",
    "for item in global_input[99:]:\n",
    "    m_level = 0\n",
    "    m_width = 0\n",
    "    for x in item:\n",
    "        level = max(y[0] for y in x)\n",
    "        width = max(y[2] for y in x)\n",
    "        if level > m_level:\n",
    "            m_level = level\n",
    "        if width > m_width:\n",
    "            m_width = width\n",
    "    max_level.append(m_level)\n",
    "    max_width.append(m_width)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2138f185",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = []\n",
    "for item in pred_test:\n",
    "    labels.extend(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5afbe78",
   "metadata": {},
   "outputs": [],
   "source": [
    "frac = []\n",
    "for item in labels:\n",
    "    l0 = sum(x==0 for x in item) / len(item)\n",
    "    l1 = sum(x==1 for x in item) / len(item)\n",
    "    l2 = sum(x==2 for x in item) / len(item)\n",
    "    frac.append([l0, l1, l2])\n",
    "\n",
    "# for item in pred_te:\n",
    "#     l0 = sum(x==0 for x in item) / len(item)\n",
    "#     l1 = sum(x==1 for x in item) / len(item)\n",
    "#     l2 = sum(x==2 for x in item) / len(item)\n",
    "#     frac.append([l0, l1, l2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5929bf33",
   "metadata": {},
   "outputs": [],
   "source": [
    "level_tox_sort = {1: 0.071428, 2: 0.0667, 3: 0.045, 6: 0.1818, 7: 0.0325, 24: 0.2780}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7412247",
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "frac0 = [item[1] for item in frac]\n",
    "level_tox = {}\n",
    "for i, k in enumerate(max_level):\n",
    "    if k not in level_tox.keys():\n",
    "        level_tox[k] = [frac0[i]]\n",
    "    else:\n",
    "        level_tox[k].append(frac0[i])\n",
    "level_tox_sort = collections.OrderedDict(sorted(level_tox.items()))\n",
    "\n",
    "scale = [0.025, 0.025, 0.025, 0.025, 0.025, 0.025, 0.025, 0.025, \n",
    "         0.025, 0.025, 0.025, 0.025, 0.025, 0.025, 0.025, 0.025, 0.025]\n",
    "x = list(level_tox_sort.keys()) \n",
    "y = [np.mean(list(level_tox_sort.values())[i]) for i in range(len(level_tox))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "177f6438",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y, s=150)\n",
    "#plt.title(\"Relations Between Depth of Conversations and the Fraction of Attackers\", size=20)\n",
    "plt.xlabel(\"Depth of Conversations\", size=15)#\n",
    "plt.ylabel(\"Attacker Ratio\", size=15)\n",
    "plt.tick_params(axis='x', labelsize=15)\n",
    "plt.tick_params(axis='y', labelsize=15)\n",
    "\n",
    "# Display the heatmap\n",
    "plt.tight_layout()\n",
    "\n",
    "# Display the heatmap\n",
    "plt.savefig(f'../result/depth_{journalist}.png', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b43039",
   "metadata": {},
   "outputs": [],
   "source": [
    "def map_id(pair):\n",
    "    map_pair = {}\n",
    "    i = 0\n",
    "    for item in pair:\n",
    "        if item[0] not in map_pair.keys():\n",
    "            map_pair[item[0]] = i\n",
    "            i += 1\n",
    "        if item[1] not in map_pair.keys():\n",
    "            map_pair[item[1]] = i\n",
    "            i += 1\n",
    "    mapped_pair = [[map_pair[item[0]], map_pair[item[1]]] for item in pair]\n",
    "    return mapped_pair, map_pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2eb25aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = [-1, 2, 2, 1, 2, 2, 0, 1, 1, 1, -1, 0, 0, 2, 1, 1, 2, 0, 2, 0, 1, 1]\n",
    "map_color = {0:'red', 1: 'green', 2: 'blue', -1: 'grey'}\n",
    "mapped_color = [map_color[item] for item in labels]\n",
    "pair = id_pair[1019]\n",
    "\n",
    "node_pairs, map_pair = map_id(id_pair[1019])\n",
    "node_list = [map_pair[item] for item in id_data[19]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adcba288",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 10}\n"
     ]
    }
   ],
   "source": [
    "missed = []\n",
    "for item in node_pairs:\n",
    "    if item[0] not in node_list:\n",
    "        missed.append(item[0])\n",
    "    if item[1] not in node_list:\n",
    "        missed.append(item[1])\n",
    "print(set(missed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fec5764",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "line": {
          "color": "grey",
          "width": 2
         },
         "mode": "lines",
         "type": "scatter",
         "x": [
          0,
          -2.5,
          null,
          -2.5,
          -3,
          null,
          -2.5,
          -2,
          null,
          -3,
          -3,
          null,
          -3,
          -3.5,
          null,
          -3.5,
          -3.5,
          null,
          -3,
          -2.5,
          null,
          0,
          -1.5,
          null,
          -3,
          -3.5,
          null,
          0,
          -0.5,
          null,
          -0.5,
          -1,
          null,
          -0.5,
          0,
          null,
          -3.5,
          -3.5,
          null,
          0,
          0.5,
          null,
          -3,
          -4,
          null,
          -3,
          -2.5,
          null,
          0.5,
          0.5,
          null,
          0.5,
          0.5,
          null,
          0.5,
          0.5,
          null,
          0,
          1.5,
          null,
          0,
          2.5,
          null
         ],
         "y": [
          0,
          -1,
          null,
          -1,
          -2,
          null,
          -1,
          -2,
          null,
          -2,
          -3,
          null,
          -3,
          -4,
          null,
          -4,
          -5,
          null,
          -3,
          -4,
          null,
          0,
          -1,
          null,
          -2,
          -3,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          -1,
          -2,
          null,
          -5,
          -6,
          null,
          0,
          -1,
          null,
          -2,
          -3,
          null,
          -2,
          -3,
          null,
          -1,
          -2,
          null,
          -2,
          -3,
          null,
          -3,
          -4,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null
         ]
        },
        {
         "marker": {
          "color": [
           "grey",
           "blue",
           "blue",
           "green",
           "blue",
           "blue",
           "red",
           "green",
           "green",
           "green",
           "grey",
           "red",
           "red",
           "blue",
           "green",
           "green",
           "blue",
           "red",
           "blue",
           "red",
           "green",
           "green"
          ],
          "line": {
           "color": "DarkSlateGrey",
           "width": 2
          },
          "size": 10
         },
         "mode": "markers",
         "text": [
          "0",
          "1",
          "2",
          "3",
          "4",
          "5",
          "6",
          "7",
          "8",
          "9",
          "10",
          "11",
          "12",
          "13",
          "14",
          "15",
          "16",
          "17",
          "18",
          "19",
          "20",
          "21"
         ],
         "textposition": "bottom center",
         "type": "scatter",
         "x": [
          0,
          -2.5,
          -3,
          -2,
          -3,
          -3.5,
          -3.5,
          -2.5,
          -1.5,
          -3.5,
          -0.5,
          -1,
          0,
          -3.5,
          0.5,
          -4,
          -2.5,
          0.5,
          0.5,
          0.5,
          1.5,
          2.5
         ],
         "y": [
          0,
          -1,
          -2,
          -2,
          -3,
          -4,
          -5,
          -4,
          -1,
          -3,
          -1,
          -2,
          -2,
          -6,
          -1,
          -3,
          -3,
          -2,
          -3,
          -4,
          -1,
          -1
         ]
        }
       ],
       "layout": {
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "white",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "white",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "#C8D4E3",
             "linecolor": "#C8D4E3",
             "minorgridcolor": "#C8D4E3",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "#C8D4E3",
             "linecolor": "#C8D4E3",
             "minorgridcolor": "#C8D4E3",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "white",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "#C8D4E3"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "white",
          "polar": {
           "angularaxis": {
            "gridcolor": "#EBF0F8",
            "linecolor": "#EBF0F8",
            "ticks": ""
           },
           "bgcolor": "white",
           "radialaxis": {
            "gridcolor": "#EBF0F8",
            "linecolor": "#EBF0F8",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           },
           "yaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           },
           "zaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           },
           "bgcolor": "white",
           "caxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "#EBF0F8",
           "linecolor": "#EBF0F8",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "#EBF0F8",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "#EBF0F8",
           "linecolor": "#EBF0F8",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "#EBF0F8",
           "zerolinewidth": 2
          }
         }
        },
        "xaxis": {
         "showgrid": false,
         "showticklabels": false,
         "zeroline": false
        },
        "yaxis": {
         "showgrid": false,
         "showticklabels": false,
         "zeroline": false
        }
       }
      },
      "text/html": [
       "<div>                            <div id=\"8d0a5750-abff-44ca-bdaa-5c84f852a7fe\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                require([\"plotly\"], function(Plotly) {                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"8d0a5750-abff-44ca-bdaa-5c84f852a7fe\")) {                    Plotly.newPlot(                        \"8d0a5750-abff-44ca-bdaa-5c84f852a7fe\",                        [{\"line\":{\"color\":\"grey\",\"width\":2},\"mode\":\"lines\",\"x\":[0,-2.5,null,-2.5,-3,null,-2.5,-2,null,-3,-3,null,-3,-3.5,null,-3.5,-3.5,null,-3,-2.5,null,0,-1.5,null,-3,-3.5,null,0,-0.5,null,-0.5,-1,null,-0.5,0,null,-3.5,-3.5,null,0,0.5,null,-3,-4,null,-3,-2.5,null,0.5,0.5,null,0.5,0.5,null,0.5,0.5,null,0,1.5,null,0,2.5,null],\"y\":[0,-1,null,-1,-2,null,-1,-2,null,-2,-3,null,-3,-4,null,-4,-5,null,-3,-4,null,0,-1,null,-2,-3,null,0,-1,null,-1,-2,null,-1,-2,null,-5,-6,null,0,-1,null,-2,-3,null,-2,-3,null,-1,-2,null,-2,-3,null,-3,-4,null,0,-1,null,0,-1,null],\"type\":\"scatter\"},{\"marker\":{\"color\":[\"grey\",\"blue\",\"blue\",\"green\",\"blue\",\"blue\",\"red\",\"green\",\"green\",\"green\",\"grey\",\"red\",\"red\",\"blue\",\"green\",\"green\",\"blue\",\"red\",\"blue\",\"red\",\"green\",\"green\"],\"line\":{\"color\":\"DarkSlateGrey\",\"width\":2},\"size\":10},\"mode\":\"markers\",\"text\":[\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"10\",\"11\",\"12\",\"13\",\"14\",\"15\",\"16\",\"17\",\"18\",\"19\",\"20\",\"21\"],\"textposition\":\"bottom center\",\"x\":[0,-2.5,-3,-2,-3,-3.5,-3.5,-2.5,-1.5,-3.5,-0.5,-1,0,-3.5,0.5,-4,-2.5,0.5,0.5,0.5,1.5,2.5],\"y\":[0,-1,-2,-2,-3,-4,-5,-4,-1,-3,-1,-2,-2,-6,-1,-3,-3,-2,-3,-4,-1,-1],\"type\":\"scatter\"}],                        {\"template\":{\"data\":{\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"white\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"white\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"#C8D4E3\",\"linecolor\":\"#C8D4E3\",\"minorgridcolor\":\"#C8D4E3\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"#C8D4E3\",\"linecolor\":\"#C8D4E3\",\"minorgridcolor\":\"#C8D4E3\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"choropleth\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"choropleth\"}],\"contourcarpet\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"contourcarpet\"}],\"contour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"contour\"}],\"heatmapgl\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmapgl\"}],\"heatmap\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmap\"}],\"histogram2dcontour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2dcontour\"}],\"histogram2d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2d\"}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"mesh3d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"mesh3d\"}],\"parcoords\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"parcoords\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}],\"scatter3d\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter3d\"}],\"scattercarpet\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattercarpet\"}],\"scattergeo\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergeo\"}],\"scattergl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergl\"}],\"scattermapbox\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattermapbox\"}],\"scatterpolargl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolargl\"}],\"scatterpolar\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolar\"}],\"scatter\":[{\"fillpattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2},\"type\":\"scatter\"}],\"scatterternary\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterternary\"}],\"surface\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"surface\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}]},\"layout\":{\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"autotypenumbers\":\"strict\",\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]],\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"geo\":{\"bgcolor\":\"white\",\"lakecolor\":\"white\",\"landcolor\":\"white\",\"showlakes\":true,\"showland\":true,\"subunitcolor\":\"#C8D4E3\"},\"hoverlabel\":{\"align\":\"left\"},\"hovermode\":\"closest\",\"mapbox\":{\"style\":\"light\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"white\",\"polar\":{\"angularaxis\":{\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\"},\"bgcolor\":\"white\",\"radialaxis\":{\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\"}},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"},\"yaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"},\"zaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"ternary\":{\"aaxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"},\"bgcolor\":\"white\",\"caxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"}},\"title\":{\"x\":0.05},\"xaxis\":{\"automargin\":true,\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"#EBF0F8\",\"zerolinewidth\":2},\"yaxis\":{\"automargin\":true,\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"#EBF0F8\",\"zerolinewidth\":2}}},\"xaxis\":{\"showgrid\":false,\"zeroline\":false,\"showticklabels\":false},\"yaxis\":{\"showgrid\":false,\"zeroline\":false,\"showticklabels\":false}},                        {\"responsive\": true}                    ).then(function(){\n",
       "                            \n",
       "var gd = document.getElementById('8d0a5750-abff-44ca-bdaa-5c84f852a7fe');\n",
       "var x = new MutationObserver(function (mutations, observer) {{\n",
       "        var display = window.getComputedStyle(gd).display;\n",
       "        if (!display || display === 'none') {{\n",
       "            console.log([gd, 'removed!']);\n",
       "            Plotly.purge(gd);\n",
       "            observer.disconnect();\n",
       "        }}\n",
       "}});\n",
       "\n",
       "// Listen for the removal of the full notebook cells\n",
       "var notebookContainer = gd.closest('#notebook-container');\n",
       "if (notebookContainer) {{\n",
       "    x.observe(notebookContainer, {childList: true});\n",
       "}}\n",
       "\n",
       "// Listen for the clearing of the current output cell\n",
       "var outputEl = gd.closest('.output');\n",
       "if (outputEl) {{\n",
       "    x.observe(outputEl, {childList: true});\n",
       "}}\n",
       "\n",
       "                        })                };                });            </script>        </div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import plotly.graph_objects as go\n",
    "\n",
    "# Example node pairs\n",
    "node_pairs = node_pairs\n",
    "\n",
    "# Function to calculate positions - this will vary greatly depending on your tree structure\n",
    "positions = {0: (0, 0), 1: (-2.5, -1), 2: (-3, -2), 3: (-2, -2), 4: (-3, -3), 5: (-3.5, -4), \n",
    "             6: (-3.5, -5), 7: (-2.5, -4), 8: (-1.5, -1), 9: (-3.5, -3), 10: (-0.5, -1), \n",
    "             11: (-1, -2), 12: (0, -2), 13: (-3.5, -6), 14: (0.5, -1), 15: (-4, -3), \n",
    "             16: (-2.5, -3), 17: (0.5, -2), 18: (0.5, -3), 19: (0.5, -4), 20: (1.5, -1), 21: (2.5, -1),}\n",
    "\n",
    "\n",
    "# Create edges\n",
    "edge_x = []\n",
    "edge_y = []\n",
    "for pair in node_pairs:\n",
    "    x0, y0 = positions[pair[0]]\n",
    "    x1, y1 = positions[pair[1]]\n",
    "    edge_x.extend([x0, x1, None])\n",
    "    edge_y.extend([y0, y1, None])\n",
    "\n",
    "# Create nodes\n",
    "node_x = [pos[0] for pos in positions.values()]\n",
    "node_y = [pos[1] for pos in positions.values()]\n",
    "\n",
    "# Create figure\n",
    "fig = go.Figure()\n",
    "\n",
    "# Add edges as lines\n",
    "fig.add_trace(go.Scatter(x=edge_x, y=edge_y, mode='lines', line=dict(width=2, color='grey')))\n",
    "\n",
    "# Add nodes as markers\n",
    "# mode='markers+text'\n",
    "fig.add_trace(go.Scatter(x=node_x, y=node_y, mode='markers', text=list(positions.keys()), textposition=\"bottom center\",\n",
    "                         marker=dict(size=10, color=mapped_color, line=dict(width=2, color='DarkSlateGrey'))))\n",
    "\n",
    "# Update layout\n",
    "fig.update_layout(template=\"plotly_white\", xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
    "                  yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))\n",
    "fig.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93d9bdf6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96432bb1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23a3a584",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 38\n",
      "[2.0, 2.0, 2.0, 2.0, 2.0, 1.0, 0.0, 0.0, 1.0, 2.0, 1.0, 1.0, 2.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]\n",
      "774\n"
     ]
    }
   ],
   "source": [
    "max_dep = 0\n",
    "max_i = 0\n",
    "for i, item in enumerate(global_input):\n",
    "    for x in item:\n",
    "        if len(x) > max_dep and i <= 99 and len(x) < 10:\n",
    "            max_dep = len(x)\n",
    "            max_i = i\n",
    "print(max_dep, max_i)\n",
    "print(label[max_i])\n",
    "print(ids[max_i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3818923",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = [-1, 2.0, 2.0, 2.0, 2.0, 2.0, 1.0, 0.0, 0.0, 1.0, \n",
    "          2.0, 1.0, 1.0, 2.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]\n",
    "map_color = {0:'red', 1: 'green', 2: 'blue', -1: 'grey'}\n",
    "mapped_color = [map_color[item] for item in labels]\n",
    "\n",
    "node_pairs, map_pair = map_id(id_pair[774])\n",
    "node_list = [map_pair[item] for item in id_data[38]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a13d981",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0}\n"
     ]
    }
   ],
   "source": [
    "missed = []\n",
    "for item in node_pairs:\n",
    "    if item[0] not in node_list:\n",
    "        missed.append(item[0])\n",
    "    if item[1] not in node_list:\n",
    "        missed.append(item[1])\n",
    "print(set(missed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95e55790",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "line": {
          "color": "grey",
          "width": 2
         },
         "mode": "lines",
         "type": "scatter",
         "x": [
          0,
          0,
          null,
          0,
          0,
          null,
          0,
          0,
          null,
          0,
          0,
          null,
          0,
          -0.5,
          null,
          0,
          0.5,
          null,
          -0.5,
          -1,
          null,
          -1,
          -1,
          null,
          -0.5,
          0,
          null,
          -1,
          -1,
          null,
          0,
          -2,
          null,
          0,
          -1.5,
          null,
          0,
          -1,
          null,
          0,
          -0.5,
          null,
          0,
          0.5,
          null,
          0,
          1,
          null,
          0,
          1.5,
          null,
          0,
          0.5,
          null,
          0,
          2,
          null,
          0,
          2.5,
          null
         ],
         "y": [
          0,
          -1,
          null,
          -1,
          -2,
          null,
          -2,
          -3,
          null,
          -3,
          -4,
          null,
          -4,
          -5,
          null,
          0,
          -1,
          null,
          -5,
          -6,
          null,
          -6,
          -7,
          null,
          -5,
          -6,
          null,
          -7,
          -8,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -4,
          -5,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null
         ]
        },
        {
         "marker": {
          "color": [
           "grey",
           "blue",
           "blue",
           "blue",
           "blue",
           "blue",
           "green",
           "red",
           "red",
           "green",
           "blue",
           "green",
           "green",
           "blue",
           "green",
           "red",
           "green",
           "red",
           "red",
           "red",
           "red"
          ],
          "line": {
           "color": "DarkSlateGrey",
           "width": 2
          },
          "size": 10
         },
         "mode": "markers",
         "text": [
          "0",
          "1",
          "2",
          "3",
          "4",
          "5",
          "6",
          "7",
          "8",
          "9",
          "10",
          "11",
          "12",
          "13",
          "14",
          "15",
          "16",
          "17",
          "18",
          "19",
          "20"
         ],
         "textposition": "bottom center",
         "type": "scatter",
         "x": [
          0,
          0,
          0,
          0,
          0,
          -0.5,
          0.5,
          -1,
          -1,
          0,
          -1,
          -2,
          -1.5,
          -1,
          -0.5,
          0.5,
          1,
          1.5,
          0.5,
          2,
          2.5
         ],
         "y": [
          0,
          -1,
          -2,
          -3,
          -4,
          -5,
          -1,
          -6,
          -7,
          -6,
          -8,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -5,
          -1,
          -1
         ]
        }
       ],
       "layout": {
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "white",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "white",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "#C8D4E3",
             "linecolor": "#C8D4E3",
             "minorgridcolor": "#C8D4E3",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "#C8D4E3",
             "linecolor": "#C8D4E3",
             "minorgridcolor": "#C8D4E3",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "white",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "#C8D4E3"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "white",
          "polar": {
           "angularaxis": {
            "gridcolor": "#EBF0F8",
            "linecolor": "#EBF0F8",
            "ticks": ""
           },
           "bgcolor": "white",
           "radialaxis": {
            "gridcolor": "#EBF0F8",
            "linecolor": "#EBF0F8",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           },
           "yaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           },
           "zaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           },
           "bgcolor": "white",
           "caxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "#EBF0F8",
           "linecolor": "#EBF0F8",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "#EBF0F8",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "#EBF0F8",
           "linecolor": "#EBF0F8",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "#EBF0F8",
           "zerolinewidth": 2
          }
         }
        },
        "xaxis": {
         "showgrid": false,
         "showticklabels": false,
         "zeroline": false
        },
        "yaxis": {
         "showgrid": false,
         "showticklabels": false,
         "zeroline": false
        }
       }
      },
      "text/html": [
       "<div>                            <div id=\"0cbc838d-47ed-4730-b927-8b8e6e2d6918\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                require([\"plotly\"], function(Plotly) {                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"0cbc838d-47ed-4730-b927-8b8e6e2d6918\")) {                    Plotly.newPlot(                        \"0cbc838d-47ed-4730-b927-8b8e6e2d6918\",                        [{\"line\":{\"color\":\"grey\",\"width\":2},\"mode\":\"lines\",\"x\":[0,0,null,0,0,null,0,0,null,0,0,null,0,-0.5,null,0,0.5,null,-0.5,-1,null,-1,-1,null,-0.5,0,null,-1,-1,null,0,-2,null,0,-1.5,null,0,-1,null,0,-0.5,null,0,0.5,null,0,1,null,0,1.5,null,0,0.5,null,0,2,null,0,2.5,null],\"y\":[0,-1,null,-1,-2,null,-2,-3,null,-3,-4,null,-4,-5,null,0,-1,null,-5,-6,null,-6,-7,null,-5,-6,null,-7,-8,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-4,-5,null,0,-1,null,0,-1,null],\"type\":\"scatter\"},{\"marker\":{\"color\":[\"grey\",\"blue\",\"blue\",\"blue\",\"blue\",\"blue\",\"green\",\"red\",\"red\",\"green\",\"blue\",\"green\",\"green\",\"blue\",\"green\",\"red\",\"green\",\"red\",\"red\",\"red\",\"red\"],\"line\":{\"color\":\"DarkSlateGrey\",\"width\":2},\"size\":10},\"mode\":\"markers\",\"text\":[\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"10\",\"11\",\"12\",\"13\",\"14\",\"15\",\"16\",\"17\",\"18\",\"19\",\"20\"],\"textposition\":\"bottom center\",\"x\":[0,0,0,0,0,-0.5,0.5,-1,-1,0,-1,-2,-1.5,-1,-0.5,0.5,1,1.5,0.5,2,2.5],\"y\":[0,-1,-2,-3,-4,-5,-1,-6,-7,-6,-8,-1,-1,-1,-1,-1,-1,-1,-5,-1,-1],\"type\":\"scatter\"}],                        {\"template\":{\"data\":{\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"white\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"white\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"#C8D4E3\",\"linecolor\":\"#C8D4E3\",\"minorgridcolor\":\"#C8D4E3\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"#C8D4E3\",\"linecolor\":\"#C8D4E3\",\"minorgridcolor\":\"#C8D4E3\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"choropleth\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"choropleth\"}],\"contourcarpet\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"contourcarpet\"}],\"contour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"contour\"}],\"heatmapgl\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmapgl\"}],\"heatmap\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmap\"}],\"histogram2dcontour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2dcontour\"}],\"histogram2d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2d\"}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"mesh3d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"mesh3d\"}],\"parcoords\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"parcoords\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}],\"scatter3d\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter3d\"}],\"scattercarpet\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattercarpet\"}],\"scattergeo\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergeo\"}],\"scattergl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergl\"}],\"scattermapbox\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattermapbox\"}],\"scatterpolargl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolargl\"}],\"scatterpolar\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolar\"}],\"scatter\":[{\"fillpattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2},\"type\":\"scatter\"}],\"scatterternary\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterternary\"}],\"surface\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"surface\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}]},\"layout\":{\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"autotypenumbers\":\"strict\",\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]],\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"geo\":{\"bgcolor\":\"white\",\"lakecolor\":\"white\",\"landcolor\":\"white\",\"showlakes\":true,\"showland\":true,\"subunitcolor\":\"#C8D4E3\"},\"hoverlabel\":{\"align\":\"left\"},\"hovermode\":\"closest\",\"mapbox\":{\"style\":\"light\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"white\",\"polar\":{\"angularaxis\":{\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\"},\"bgcolor\":\"white\",\"radialaxis\":{\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\"}},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"},\"yaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"},\"zaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"ternary\":{\"aaxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"},\"bgcolor\":\"white\",\"caxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"}},\"title\":{\"x\":0.05},\"xaxis\":{\"automargin\":true,\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"#EBF0F8\",\"zerolinewidth\":2},\"yaxis\":{\"automargin\":true,\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"#EBF0F8\",\"zerolinewidth\":2}}},\"xaxis\":{\"showgrid\":false,\"zeroline\":false,\"showticklabels\":false},\"yaxis\":{\"showgrid\":false,\"zeroline\":false,\"showticklabels\":false}},                        {\"responsive\": true}                    ).then(function(){\n",
       "                            \n",
       "var gd = document.getElementById('0cbc838d-47ed-4730-b927-8b8e6e2d6918');\n",
       "var x = new MutationObserver(function (mutations, observer) {{\n",
       "        var display = window.getComputedStyle(gd).display;\n",
       "        if (!display || display === 'none') {{\n",
       "            console.log([gd, 'removed!']);\n",
       "            Plotly.purge(gd);\n",
       "            observer.disconnect();\n",
       "        }}\n",
       "}});\n",
       "\n",
       "// Listen for the removal of the full notebook cells\n",
       "var notebookContainer = gd.closest('#notebook-container');\n",
       "if (notebookContainer) {{\n",
       "    x.observe(notebookContainer, {childList: true});\n",
       "}}\n",
       "\n",
       "// Listen for the clearing of the current output cell\n",
       "var outputEl = gd.closest('.output');\n",
       "if (outputEl) {{\n",
       "    x.observe(outputEl, {childList: true});\n",
       "}}\n",
       "\n",
       "                        })                };                });            </script>        </div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import plotly.graph_objects as go\n",
    "\n",
    "# Example node pairs\n",
    "node_pairs = node_pairs\n",
    "\n",
    "# Function to calculate positions - this will vary greatly depending on your tree structure\n",
    "positions = {0: (0, 0), 1: (0, -1), 2: (0, -2), 3: (0, -3), 4: (0, -4), 5: (-0.5, -5), \n",
    "             6: (0.5, -1), 7: (-1, -6), 8: (-1, -7), 9: (0, -6), 10: (-1, -8), \n",
    "             11: (-2, -1), 12: (-1.5, -1), 13: (-1, -1), 14: (-0.5, -1), 15: (0.5, -1), \n",
    "             16: (1, -1), 17: (1.5, -1), 18: (0.5, -5), 19: (2, -1), 20: (2.5, -1)}\n",
    "\n",
    "\n",
    "# Create edges\n",
    "edge_x = []\n",
    "edge_y = []\n",
    "for pair in node_pairs:\n",
    "    x0, y0 = positions[pair[0]]\n",
    "    x1, y1 = positions[pair[1]]\n",
    "    edge_x.extend([x0, x1, None])\n",
    "    edge_y.extend([y0, y1, None])\n",
    "\n",
    "# Create nodes\n",
    "node_x = [pos[0] for pos in positions.values()]\n",
    "node_y = [pos[1] for pos in positions.values()]\n",
    "\n",
    "# Create figure\n",
    "fig = go.Figure()\n",
    "\n",
    "# Add edges as lines\n",
    "fig.add_trace(go.Scatter(x=edge_x, y=edge_y, mode='lines', line=dict(width=2, color='grey')))\n",
    "\n",
    "# Add nodes as markers\n",
    "# mode='markers+text'\n",
    "fig.add_trace(go.Scatter(x=node_x, y=node_y, mode='markers', text=list(positions.keys()), textposition=\"bottom center\",\n",
    "                         marker=dict(size=10, color=mapped_color, line=dict(width=2, color='DarkSlateGrey'))))\n",
    "\n",
    "# Update layout\n",
    "fig.update_layout(template=\"plotly_white\", xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
    "                  yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))\n",
    "fig.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dcb640d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92dc180d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40b3beba",
   "metadata": {},
   "outputs": [],
   "source": [
    "node_pairs, map_pair = map_id(id_pair[579])\n",
    "node_list = [map_pair[item] for item in id_data[22]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9d6a84c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 64, 51, 86}\n"
     ]
    }
   ],
   "source": [
    "missed = []\n",
    "for item in node_pairs:\n",
    "    if item[0] not in node_list:\n",
    "        missed.append(item[0])\n",
    "    if item[1] not in node_list:\n",
    "        missed.append(item[1])\n",
    "print(set(missed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28c08a46",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = [-1, 2, 2, 1, 1, 1, 1, 1, 1, 1, \n",
    "          1, 1, 2, 1, 1, 1, 1, 1, 2, 1, \n",
    "          0, 1, 1, 1, 2, 2, 1, 1, 1, 1, \n",
    "          1, 1, 1, 2, 1, 0, 1, 1, 0, 1, \n",
    "          0, 1, 1, 1, 1, 1, 1, 1, 1, 1, \n",
    "          1, -1, 1, 2, 1, 1, 1, 0, 1, 1, \n",
    "          2, 1, 0, 2, -1, 1, 1, 1, 1, 1, \n",
    "          1, 1, 1, 1, 1, 1, 1, 0, 0, 0, \n",
    "          1, 1, 1, 1, 1, 1, -1, 1, 1, 1]\n",
    "map_color = {0:'red', 1: 'green', 2: 'blue', -1: 'grey'}\n",
    "mapped_color = [map_color[item] for item in labels]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b67c14a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "line": {
          "color": "grey",
          "width": 2
         },
         "mode": "lines",
         "type": "scatter",
         "x": [
          0,
          -35,
          null,
          0,
          -34,
          null,
          0,
          -33,
          null,
          0,
          -32,
          null,
          0,
          -31,
          null,
          0,
          -30,
          null,
          0,
          -29,
          null,
          0,
          -28,
          null,
          0,
          -27,
          null,
          -33,
          -33,
          null,
          -27,
          -27,
          null,
          0,
          -26,
          null,
          -30,
          -30,
          null,
          0,
          -25,
          null,
          0,
          -24,
          null,
          -25,
          -25,
          null,
          0,
          -23,
          null,
          0,
          -22,
          null,
          0,
          -21,
          null,
          -22,
          -23,
          null,
          0,
          -20,
          null,
          0,
          -19,
          null,
          0,
          -18,
          null,
          0,
          -17,
          null,
          0,
          -16,
          null,
          0,
          -15,
          null,
          0,
          -14,
          null,
          0,
          -13,
          null,
          0,
          -12,
          null,
          0,
          -11,
          null,
          -33,
          -33,
          null,
          0,
          -10,
          null,
          0,
          -9,
          null,
          -23,
          -23,
          null,
          0,
          -8,
          null,
          0,
          -7,
          null,
          0,
          -6,
          null,
          0,
          -5,
          null,
          -22,
          -21,
          null,
          0,
          -4,
          null,
          0,
          -3,
          null,
          0,
          -2,
          null,
          0,
          -1,
          null,
          0,
          1,
          null,
          -1,
          -2,
          null,
          0,
          2,
          null,
          0,
          3,
          null,
          0,
          4,
          null,
          0,
          5,
          null,
          0,
          6,
          null,
          0,
          7,
          null,
          7,
          6,
          null,
          0,
          8,
          null,
          0,
          9,
          null,
          0,
          10,
          null,
          0,
          11,
          null,
          0,
          12,
          null,
          0,
          13,
          null,
          0,
          14,
          null,
          0,
          15,
          null,
          0,
          16,
          null,
          15,
          14,
          null,
          14,
          14,
          null,
          0,
          17,
          null,
          17,
          17,
          null,
          0,
          19,
          null,
          0,
          20,
          null,
          20,
          21,
          null,
          21,
          20,
          null,
          0,
          21,
          null,
          0,
          22,
          null,
          22,
          23,
          null,
          23,
          23,
          null,
          0,
          23,
          null,
          0,
          24,
          null,
          0,
          25,
          null,
          0,
          26,
          null,
          0,
          27,
          null,
          0,
          28,
          null,
          0,
          29,
          null,
          0,
          30,
          null,
          0,
          31,
          null,
          0,
          32,
          null,
          0,
          33,
          null,
          0,
          34,
          null,
          0,
          35,
          null,
          35,
          35,
          null,
          0,
          36,
          null,
          14,
          14,
          null
         ],
         "y": [
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -2,
          -3,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -2,
          -3,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          -2,
          -3,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          -2,
          -3,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          0,
          -1,
          null,
          -1,
          -2,
          null,
          0,
          -1,
          null,
          -3,
          -4,
          null
         ]
        },
        {
         "marker": {
          "color": [
           "grey",
           "blue",
           "blue",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "blue",
           "green",
           "green",
           "green",
           "green",
           "green",
           "blue",
           "green",
           "red",
           "green",
           "green",
           "green",
           "blue",
           "blue",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "blue",
           "green",
           "red",
           "green",
           "green",
           "red",
           "green",
           "red",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "grey",
           "green",
           "blue",
           "green",
           "green",
           "green",
           "red",
           "green",
           "green",
           "blue",
           "green",
           "red",
           "blue",
           "grey",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "red",
           "red",
           "red",
           "green",
           "green",
           "green",
           "green",
           "green",
           "green",
           "grey",
           "green",
           "green",
           "green"
          ],
          "line": {
           "color": "DarkSlateGrey",
           "width": 2
          },
          "size": 10
         },
         "mode": "markers",
         "text": [
          "0",
          "1",
          "2",
          "3",
          "4",
          "5",
          "6",
          "7",
          "8",
          "9",
          "10",
          "11",
          "12",
          "13",
          "14",
          "15",
          "16",
          "17",
          "18",
          "19",
          "20",
          "21",
          "22",
          "23",
          "24",
          "25",
          "26",
          "27",
          "28",
          "29",
          "30",
          "31",
          "32",
          "33",
          "34",
          "35",
          "36",
          "37",
          "38",
          "39",
          "40",
          "41",
          "42",
          "43",
          "44",
          "45",
          "46",
          "47",
          "48",
          "49",
          "50",
          "51",
          "52",
          "53",
          "54",
          "55",
          "56",
          "57",
          "58",
          "59",
          "60",
          "61",
          "62",
          "63",
          "64",
          "65",
          "66",
          "67",
          "68",
          "69",
          "70",
          "71",
          "72",
          "73",
          "74",
          "75",
          "76",
          "77",
          "78",
          "79",
          "80",
          "81",
          "82",
          "83",
          "84",
          "85",
          "86",
          "87",
          "88",
          "89"
         ],
         "textposition": "bottom center",
         "type": "scatter",
         "x": [
          0,
          -35,
          -34,
          -33,
          -32,
          -31,
          -30,
          -29,
          -28,
          -27,
          -33,
          -27,
          -26,
          -30,
          -25,
          -24,
          -25,
          -23,
          -22,
          -21,
          -23,
          -20,
          -19,
          -18,
          -17,
          -16,
          -15,
          -14,
          -13,
          -12,
          -11,
          -33,
          -10,
          -9,
          -23,
          -8,
          -7,
          -6,
          -5,
          -21,
          -4,
          -3,
          -2,
          -1,
          1,
          -2,
          2,
          3,
          4,
          5,
          6,
          7,
          6,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          14,
          14,
          17,
          17,
          19,
          20,
          21,
          20,
          21,
          22,
          23,
          23,
          23,
          24,
          25,
          26,
          27,
          28,
          29,
          30,
          31,
          32,
          33,
          34,
          35,
          35,
          36,
          14
         ],
         "y": [
          0,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -2,
          -2,
          -1,
          -2,
          -1,
          -1,
          -2,
          -1,
          -1,
          -1,
          -2,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -3,
          -1,
          -1,
          -3,
          -1,
          -1,
          -1,
          -1,
          -2,
          -1,
          -1,
          -1,
          -1,
          -1,
          -2,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -2,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -2,
          -3,
          -1,
          -2,
          -1,
          -1,
          -1,
          -2,
          -1,
          -1,
          -2,
          -3,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -1,
          -2,
          -1,
          -4
         ]
        }
       ],
       "layout": {
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "white",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "white",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "#C8D4E3",
             "linecolor": "#C8D4E3",
             "minorgridcolor": "#C8D4E3",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "#C8D4E3",
             "linecolor": "#C8D4E3",
             "minorgridcolor": "#C8D4E3",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "white",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "#C8D4E3"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "white",
          "polar": {
           "angularaxis": {
            "gridcolor": "#EBF0F8",
            "linecolor": "#EBF0F8",
            "ticks": ""
           },
           "bgcolor": "white",
           "radialaxis": {
            "gridcolor": "#EBF0F8",
            "linecolor": "#EBF0F8",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           },
           "yaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           },
           "zaxis": {
            "backgroundcolor": "white",
            "gridcolor": "#DFE8F3",
            "gridwidth": 2,
            "linecolor": "#EBF0F8",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "#EBF0F8"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           },
           "bgcolor": "white",
           "caxis": {
            "gridcolor": "#DFE8F3",
            "linecolor": "#A2B1C6",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "#EBF0F8",
           "linecolor": "#EBF0F8",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "#EBF0F8",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "#EBF0F8",
           "linecolor": "#EBF0F8",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "#EBF0F8",
           "zerolinewidth": 2
          }
         }
        },
        "xaxis": {
         "showgrid": false,
         "showticklabels": false,
         "zeroline": false
        },
        "yaxis": {
         "showgrid": false,
         "showticklabels": false,
         "zeroline": false
        }
       }
      },
      "text/html": [
       "<div>                            <div id=\"3482238d-3a66-4d72-9d26-fe7194e2cf8b\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                require([\"plotly\"], function(Plotly) {                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"3482238d-3a66-4d72-9d26-fe7194e2cf8b\")) {                    Plotly.newPlot(                        \"3482238d-3a66-4d72-9d26-fe7194e2cf8b\",                        [{\"line\":{\"color\":\"grey\",\"width\":2},\"mode\":\"lines\",\"x\":[0,-35,null,0,-34,null,0,-33,null,0,-32,null,0,-31,null,0,-30,null,0,-29,null,0,-28,null,0,-27,null,-33,-33,null,-27,-27,null,0,-26,null,-30,-30,null,0,-25,null,0,-24,null,-25,-25,null,0,-23,null,0,-22,null,0,-21,null,-22,-23,null,0,-20,null,0,-19,null,0,-18,null,0,-17,null,0,-16,null,0,-15,null,0,-14,null,0,-13,null,0,-12,null,0,-11,null,-33,-33,null,0,-10,null,0,-9,null,-23,-23,null,0,-8,null,0,-7,null,0,-6,null,0,-5,null,-22,-21,null,0,-4,null,0,-3,null,0,-2,null,0,-1,null,0,1,null,-1,-2,null,0,2,null,0,3,null,0,4,null,0,5,null,0,6,null,0,7,null,7,6,null,0,8,null,0,9,null,0,10,null,0,11,null,0,12,null,0,13,null,0,14,null,0,15,null,0,16,null,15,14,null,14,14,null,0,17,null,17,17,null,0,19,null,0,20,null,20,21,null,21,20,null,0,21,null,0,22,null,22,23,null,23,23,null,0,23,null,0,24,null,0,25,null,0,26,null,0,27,null,0,28,null,0,29,null,0,30,null,0,31,null,0,32,null,0,33,null,0,34,null,0,35,null,35,35,null,0,36,null,14,14,null],\"y\":[0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,-1,-2,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-2,-3,null,0,-1,null,0,-1,null,-2,-3,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,-2,-3,null,0,-1,null,-1,-2,null,0,-1,null,0,-1,null,-1,-1,null,-1,-2,null,0,-1,null,0,-1,null,-1,-2,null,-2,-3,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,0,-1,null,-1,-2,null,0,-1,null,-3,-4,null],\"type\":\"scatter\"},{\"marker\":{\"color\":[\"grey\",\"blue\",\"blue\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"blue\",\"green\",\"green\",\"green\",\"green\",\"green\",\"blue\",\"green\",\"red\",\"green\",\"green\",\"green\",\"blue\",\"blue\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"blue\",\"green\",\"red\",\"green\",\"green\",\"red\",\"green\",\"red\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"grey\",\"green\",\"blue\",\"green\",\"green\",\"green\",\"red\",\"green\",\"green\",\"blue\",\"green\",\"red\",\"blue\",\"grey\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"red\",\"red\",\"red\",\"green\",\"green\",\"green\",\"green\",\"green\",\"green\",\"grey\",\"green\",\"green\",\"green\"],\"line\":{\"color\":\"DarkSlateGrey\",\"width\":2},\"size\":10},\"mode\":\"markers\",\"text\":[\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"10\",\"11\",\"12\",\"13\",\"14\",\"15\",\"16\",\"17\",\"18\",\"19\",\"20\",\"21\",\"22\",\"23\",\"24\",\"25\",\"26\",\"27\",\"28\",\"29\",\"30\",\"31\",\"32\",\"33\",\"34\",\"35\",\"36\",\"37\",\"38\",\"39\",\"40\",\"41\",\"42\",\"43\",\"44\",\"45\",\"46\",\"47\",\"48\",\"49\",\"50\",\"51\",\"52\",\"53\",\"54\",\"55\",\"56\",\"57\",\"58\",\"59\",\"60\",\"61\",\"62\",\"63\",\"64\",\"65\",\"66\",\"67\",\"68\",\"69\",\"70\",\"71\",\"72\",\"73\",\"74\",\"75\",\"76\",\"77\",\"78\",\"79\",\"80\",\"81\",\"82\",\"83\",\"84\",\"85\",\"86\",\"87\",\"88\",\"89\"],\"textposition\":\"bottom center\",\"x\":[0,-35,-34,-33,-32,-31,-30,-29,-28,-27,-33,-27,-26,-30,-25,-24,-25,-23,-22,-21,-23,-20,-19,-18,-17,-16,-15,-14,-13,-12,-11,-33,-10,-9,-23,-8,-7,-6,-5,-21,-4,-3,-2,-1,1,-2,2,3,4,5,6,7,6,8,9,10,11,12,13,14,15,16,14,14,17,17,19,20,21,20,21,22,23,23,23,24,25,26,27,28,29,30,31,32,33,34,35,35,36,14],\"y\":[0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-2,-1,-2,-1,-1,-2,-1,-1,-1,-2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-3,-1,-1,-3,-1,-1,-1,-1,-2,-1,-1,-1,-1,-1,-2,-1,-1,-1,-1,-1,-1,-2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-3,-1,-2,-1,-1,-1,-2,-1,-1,-2,-3,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-2,-1,-4],\"type\":\"scatter\"}],                        {\"template\":{\"data\":{\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"white\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"white\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"#C8D4E3\",\"linecolor\":\"#C8D4E3\",\"minorgridcolor\":\"#C8D4E3\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"#C8D4E3\",\"linecolor\":\"#C8D4E3\",\"minorgridcolor\":\"#C8D4E3\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"choropleth\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"choropleth\"}],\"contourcarpet\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"contourcarpet\"}],\"contour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"contour\"}],\"heatmapgl\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmapgl\"}],\"heatmap\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"heatmap\"}],\"histogram2dcontour\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2dcontour\"}],\"histogram2d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"histogram2d\"}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"mesh3d\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"type\":\"mesh3d\"}],\"parcoords\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"parcoords\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}],\"scatter3d\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatter3d\"}],\"scattercarpet\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattercarpet\"}],\"scattergeo\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergeo\"}],\"scattergl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattergl\"}],\"scattermapbox\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scattermapbox\"}],\"scatterpolargl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolargl\"}],\"scatterpolar\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterpolar\"}],\"scatter\":[{\"fillpattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2},\"type\":\"scatter\"}],\"scatterternary\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"type\":\"scatterternary\"}],\"surface\":[{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"type\":\"surface\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}]},\"layout\":{\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"autotypenumbers\":\"strict\",\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]],\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]},\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"geo\":{\"bgcolor\":\"white\",\"lakecolor\":\"white\",\"landcolor\":\"white\",\"showlakes\":true,\"showland\":true,\"subunitcolor\":\"#C8D4E3\"},\"hoverlabel\":{\"align\":\"left\"},\"hovermode\":\"closest\",\"mapbox\":{\"style\":\"light\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"white\",\"polar\":{\"angularaxis\":{\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\"},\"bgcolor\":\"white\",\"radialaxis\":{\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\"}},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"},\"yaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"},\"zaxis\":{\"backgroundcolor\":\"white\",\"gridcolor\":\"#DFE8F3\",\"gridwidth\":2,\"linecolor\":\"#EBF0F8\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"#EBF0F8\"}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"ternary\":{\"aaxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"},\"bgcolor\":\"white\",\"caxis\":{\"gridcolor\":\"#DFE8F3\",\"linecolor\":\"#A2B1C6\",\"ticks\":\"\"}},\"title\":{\"x\":0.05},\"xaxis\":{\"automargin\":true,\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"#EBF0F8\",\"zerolinewidth\":2},\"yaxis\":{\"automargin\":true,\"gridcolor\":\"#EBF0F8\",\"linecolor\":\"#EBF0F8\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"#EBF0F8\",\"zerolinewidth\":2}}},\"xaxis\":{\"showgrid\":false,\"zeroline\":false,\"showticklabels\":false},\"yaxis\":{\"showgrid\":false,\"zeroline\":false,\"showticklabels\":false}},                        {\"responsive\": true}                    ).then(function(){\n",
       "                            \n",
       "var gd = document.getElementById('3482238d-3a66-4d72-9d26-fe7194e2cf8b');\n",
       "var x = new MutationObserver(function (mutations, observer) {{\n",
       "        var display = window.getComputedStyle(gd).display;\n",
       "        if (!display || display === 'none') {{\n",
       "            console.log([gd, 'removed!']);\n",
       "            Plotly.purge(gd);\n",
       "            observer.disconnect();\n",
       "        }}\n",
       "}});\n",
       "\n",
       "// Listen for the removal of the full notebook cells\n",
       "var notebookContainer = gd.closest('#notebook-container');\n",
       "if (notebookContainer) {{\n",
       "    x.observe(notebookContainer, {childList: true});\n",
       "}}\n",
       "\n",
       "// Listen for the clearing of the current output cell\n",
       "var outputEl = gd.closest('.output');\n",
       "if (outputEl) {{\n",
       "    x.observe(outputEl, {childList: true});\n",
       "}}\n",
       "\n",
       "                        })                };                });            </script>        </div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "import plotly.graph_objects as go\n",
    "\n",
    "# Example node pairs\n",
    "node_pairs = node_pairs\n",
    "\n",
    "# Function to calculate positions - this will vary greatly depending on your tree structure\n",
    "positions = {0: (0, 0), 1: (-35, -1), 2: (-34, -1), 3: (-33, -1), 4: (-32, -1), 5: (-31, -1), 6: (-30, -1), 7: (-29, -1), 8: (-28, -1), 9: (-27, -1), \n",
    "             10: (-33, -2), 11: (-27, -2), 12: (-26, -1), 13: (-30, -2), 14: (-25, -1), 15: (-24, -1), 16: (-25, -2), 17: (-23, -1), 18: (-22, -1), 19: (-21, -1), \n",
    "             20: (-23, -2), 21: (-20, -1), 22: (-19, -1), 23: (-18, -1), 24: (-17, -1), 25: (-16, -1), 26: (-15, -1), 27: (-14, -1), 28: (-13, -1), 29: (-12, -1), \n",
    "             30: (-11, -1), 31: (-33, -3), 32: (-10, -1), 33: (-9, -1), 34: (-23, -3), 35: (-8, -1), 36: (-7, -1), 37: (-6, -1), 38: (-5, -1), 39: (-21, -2), \n",
    "             40: (-4, -1), 41: (-3, -1), 42: (-2, -1), 43: (-1, -1), 44: (1, -1), 45: (-2, -2), 46: (2, -1), 47: (3, -1), 48: (4, -1), 49: (5, -1), \n",
    "             50: (6, -1), 51: (7, -1), 52: (6, -2), 53: (8, -1), 54: (9, -1), 55: (10, -1), 56: (11, -1), 57: (12, -1), 58: (13, -1), 59: (14, -1), \n",
    "             60: (15, -1), 61: (16, -1), 62: (14, -2), 63: (14, -3), 64: (17, -1), 65: (17, -2), 66: (19, -1), 67: (20, -1), 68: (21, -1), 69: (20, -2), \n",
    "             70: (21, -1), 71: (22, -1), 72: (23, -2), 73: (23, -3), 74: (23, -1), 75: (24, -1), 76: (25, -1), 77: (26, -1), 78: (27, -1), 79: (28, -1), \n",
    "             80: (29, -1), 81: (30, -1), 82: (31, -1), 83: (32, -1), 84: (33, -1), 85: (34, -1), 86: (35, -1), 87: (35, -2), 88: (36, -1), 89: (14, -4), }\n",
    "\n",
    "\n",
    "# Create edges\n",
    "edge_x = []\n",
    "edge_y = []\n",
    "for pair in node_pairs:\n",
    "    x0, y0 = positions[pair[0]]\n",
    "    x1, y1 = positions[pair[1]]\n",
    "    edge_x.extend([x0, x1, None])\n",
    "    edge_y.extend([y0, y1, None])\n",
    "\n",
    "# Create nodes\n",
    "node_x = [pos[0] for pos in positions.values()]\n",
    "node_y = [pos[1] for pos in positions.values()]\n",
    "\n",
    "# Create figure\n",
    "fig = go.Figure()\n",
    "\n",
    "# Add edges as lines\n",
    "fig.add_trace(go.Scatter(x=edge_x, y=edge_y, mode='lines', line=dict(width=2, color='grey')))\n",
    "\n",
    "# Add nodes as markers\n",
    "# mode='markers+text'\n",
    "fig.add_trace(go.Scatter(x=node_x, y=node_y, mode='markers', text=list(positions.keys()), textposition=\"bottom center\",\n",
    "                         marker=dict(size=10, color=mapped_color, line=dict(width=2, color='DarkSlateGrey'))))\n",
    "\n",
    "# Update layout\n",
    "fig.update_layout(template=\"plotly_white\", xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
    "                  yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))\n",
    "fig.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e564720",
   "metadata": {},
   "source": [
    "## Strat Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "083e55ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2634/2634 [00:00<00:00, 5729.11it/s]\n",
      "100%|██████████| 2634/2634 [00:00<00:00, 5477.28it/s]\n"
     ]
    }
   ],
   "source": [
    "def collate(batch):\n",
    "    batch_li = [list(item) for item in batch]\n",
    "    data_temp = [row[0] for row in batch_li]\n",
    "    labels_temp = [torch.Tensor(row[1]) for row in batch_li]\n",
    "    prob_temp = [torch.Tensor(row[2]) for row in batch_li]\n",
    "    global_path_temp = [row[3] for row in batch_li]\n",
    "    local_path_temp = [row[4] for row in batch_li]\n",
    "    idx_temp = [torch.Tensor(row[5]) for row in batch_li]\n",
    "    \n",
    "\n",
    "    padded_data, masks = pad_sequences(data_temp, max_dim=500, pad_token=0)\n",
    "    padded_labels = pad_labels(labels_temp, max_dim=500, pad_token=0)\n",
    "    padded_idx = pad_labels(idx_temp, max_dim=500, pad_token=0)\n",
    "    padded_prob, _ = pad_sequences(prob_temp, max_dim=500, pad_token=0)\n",
    "    padded_global, _ = pad_sequences(summ(global_path_temp), max_dim=500, pad_token=0)\n",
    "    padded_local = pad_matrix(local_path_temp, max_dim=500, pad_token=0)\n",
    "\n",
    "    data= torch.tensor(padded_data).to(torch.int64)\n",
    "    labels = torch.tensor(padded_labels).to(torch.int64)\n",
    "    idx = torch.tensor(padded_idx).to(torch.int64)\n",
    "    prob = torch.tensor(padded_prob).to(torch.float64)\n",
    "    global_path = torch.tensor(np.array(padded_global)).to(torch.int64)\n",
    "    #print(type(padded_data), type(padded_data[0]))\n",
    "    local_path = torch.tensor(np.array(padded_local)).to(torch.int64)\n",
    "    #labels = torch.nn.utils.rnn.pad_sequence(labels_temp, batch_first=True)\n",
    "    #prob = torch.nn.utils.rnn.pad_sequence(prob_temp, batch_first=True)\n",
    "    #global_path = torch.nn.utils.rnn.pad_sequence(global_path_temp, batch_first=True)\n",
    "    #local_path = torch.nn.utils.rnn.pad_sequence(local_path_temp, batch_first=True)\n",
    "    #print(masks)\n",
    "    \n",
    "    #out_tweet_type = torch.nn.utils.rnn.pad_sequence(out_tweet_types, batch_first=True)\n",
    "    #print(\"start\")\n",
    "    return Batch(idx, data, labels, prob, global_path, local_path, torch.tensor(masks))\n",
    "    \n",
    "   \n",
    "def load_data(data_dir, journalist, classes, batch_size, collate):\n",
    "    ### Data (normalize input inter-event times, then padding to create dataloaders)\n",
    "    num_classes, num_sequences = 0, 0\n",
    "    seq_dataset = []\n",
    "    arr = []\n",
    "    dp = []\n",
    "    rel = []\n",
    "    \n",
    "    split = [80, 84]\n",
    "    val = 0\n",
    "    journal_sort = pd.read_csv((os.path.join(data_dir, f'{journalist}/{journalist}_conv_labels.csv')))\n",
    "    ids = []\n",
    "    for item in list(journal_sort['conversation_id']):\n",
    "        if item not in ids:\n",
    "            ids.append(item)\n",
    "    id_pair = {}\n",
    "    id_conv = {}\n",
    "    for idx in ids:\n",
    "        id_pair[idx], id_conv[idx] = create_conversation_list(journal_sort[journal_sort['conversation_id']==idx], idx)\n",
    "    id_data, data, label = create_data(journal_sort, ids)\n",
    "    prob = pkl.load(open(os.path.join(data_dir, f'{journalist}/{journalist}_edgeprob.pkl'), 'rb'))\n",
    "    \n",
    "    with open(os.path.join(data_dir, f'{journalist}/{journalist}_global_path.txt'), \"r\") as f:\n",
    "        for line in tqdm(f, total=get_number_of_lines(f)):\n",
    "            dp.append(json.loads(line.strip()))\n",
    "\n",
    "    with open(os.path.join(data_dir, f'{journalist}/{journalist}_local_path.txt'), \"r\") as f:\n",
    "        for line in tqdm(f, total=get_number_of_lines(f)):\n",
    "            rel.append(json.loads(line.strip()))\n",
    "    \n",
    "    global_input = convert_global(dp, id_data)\n",
    "    local_data = convert_local(rel)\n",
    "    local_mat = generate_local_mat(local_data, id_data)\n",
    "    local_input = create_mat(local_mat, mat_type='concat')\n",
    "    logging.info(f'loaded split {journalist}...')\n",
    "    # data - dict: dim_process, devtest, args, train, dev, test, index (train/dev/test given as)\n",
    "    # data[split] - list dicts {'time_since_start': at, 'time_since_last_event': dt, 'type_event': mark} or\n",
    "    # data[split] - dict {'arrival_times', 'delta_times', 'marks'}\n",
    "    # data['dim_process'] = Number of accounts = 119,298\n",
    "    # num_sequences: number of conversations of a journalist\n",
    "    num_classes = classes\n",
    "    #num_sequences += len(data[split]['arrival_times'])\n",
    "    num_sequences = len(set(journal_sort['conversation_id']))\n",
    "    \n",
    "    id_train, id_dev, id_test = id_data[:split[0]], id_data[split[0]:split[1]], id_data[split[1]:]\n",
    "    X_train, X_dev, X_test = data[:split[0]], data[split[0]:split[1]], data[split[1]:]\n",
    "    prob_train, prob_dev, prob_test = prob[:split[0]], prob[split[0]:split[1]], prob[split[1]:]\n",
    "    global_train, global_dev, global_test = global_input[:split[0]], global_input[split[0]:split[1]], global_input[split[1]:]\n",
    "    local_train, local_dev, local_test = local_input[:split[0]], local_input[split[0]:split[1]], local_input[split[1]:]\n",
    "    label_train, label_dev, label_test = label[:split[0]], label[split[0]:split[1]], label[split[1]:]\n",
    "\n",
    "    d_train = TreeDataset(id_train, X_train, prob_train, global_train, local_train, label_train)\n",
    "    d_val = TreeDataset(id_dev, X_dev, prob_dev, global_dev, local_dev, label_dev)  \n",
    "    d_test  = TreeDataset(id_test, X_test, prob_test, global_test, local_test, label_test)   \n",
    "\n",
    "    # for padding input sequences to maxlen of batch for running on gpu, and arranging them by length efficient\n",
    "    collate = collate  \n",
    "    dl_train = torch.utils.data.DataLoader(d_train, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "    dl_val = torch.utils.data.DataLoader(d_val, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "    dl_test = torch.utils.data.DataLoader(d_test, batch_size=batch_size, shuffle=False, collate_fn=collate)\n",
    "    return dl_train, dl_val, dl_test\n",
    "\n",
    "train, val, test = load_data(out_dir, journalist, 3, batch_size, collate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e41ff3a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8088396299383888\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "result = []\n",
    "for i in range(len(llh)):\n",
    "    a = np.array(llh[i])\n",
    "    b = np.array(strat_tr[i])\n",
    "    hit = np.sum(np.sum(a * b, axis=-1) >= 0.7)\n",
    "    count += 1\n",
    "    result.append(hit / len(llh[i]))\n",
    "print(np.sum(result) / count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c22220a",
   "metadata": {},
   "outputs": [],
   "source": [
    "llh = []\n",
    "for item in train:\n",
    "    mask = item.masks.float()\n",
    "    mask_bool = mask.bool()\n",
    "    sum = item.prob.sum(dim=-1, keepdim=True)\n",
    "    result = item.prob / sum\n",
    "    llh.append(result[mask_bool].tolist())\n",
    "likelihood = []\n",
    "for i in range(len(llh)):\n",
    "    a = np.array(llh[i])\n",
    "    b = np.array(strat_tr[i])\n",
    "    likelihood.append(np.sum(a * b, axis=-1).tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a71b6ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten(lst):\n",
    "    \"\"\" Flatten a 2D list into a 1D list \"\"\"\n",
    "    return [item for sublist in lst for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1ba4955",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "632"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.sum(binary_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77c58822",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7532777115613826, Precision: 1.0, Recall: 0.7532777115613826, F1 Score: 0.8592794017675051\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/u/yian3/.conda/envs/py39/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1497: UndefinedMetricWarning:\n",
      "\n",
      "Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\n",
    "\n",
    "# Assuming `predictions` is your list/array of predicted probabilities and `true_labels` is your ground truth\n",
    "predictions = likelihood\n",
    "true_labels = flatten([[1] * len(likelihood[i]) for i in range(len(likelihood))])\n",
    "\n",
    "# Convert probabilities to binary predictions (e.g., using 0.5 as a threshold)\n",
    "binary_predictions = flatten([[1 if p > 0.7 else 0 for p in item] for item in predictions])\n",
    "\n",
    "# Evaluate\n",
    "accuracy = accuracy_score(true_labels, binary_predictions)\n",
    "precision = precision_score(true_labels, binary_predictions)\n",
    "recall = recall_score(true_labels, binary_predictions, average='weighted', zero_division='warn')\n",
    "f1 = f1_score(true_labels, binary_predictions)\n",
    "#roc_auc = roc_auc_score(true_labels, binary_predictions)  # Note: ROC AUC uses the probabilities, not the binary predictions\n",
    "\n",
    "print(f\"Accuracy: {accuracy}, Precision: {precision}, Recall: {recall}, F1 Score: {f1}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f448a85c",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bb96f17",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels_tr = []\n",
    "strat_tr = []\n",
    "for i, item in enumerate(val):  # Assuming 'val' is your validation dataset\n",
    "    # Forward pass\n",
    "    #print(i)\n",
    "    mask = item.masks.float()\n",
    "    mask_bool = mask.bool()\n",
    "    labels = item.labels[mask_bool]\n",
    "    strat_temp = torch.Tensor(strat_val[i])\n",
    "    #pred_temp = torch.Tensor(pred_test[i])\n",
    "    strat_tr.append(strat_temp[mask_bool].tolist())\n",
    "    #labels_tr.append(pred_temp[mask_bool].tolist())\n",
    "    labels_tr.append(labels.tolist())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867aff65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150 14 7\n"
     ]
    }
   ],
   "source": [
    "strat_0 = []\n",
    "strat_1 = []\n",
    "strat_2 = []\n",
    "for i in range(len(labels_tr)):\n",
    "    for j, item in enumerate(labels_tr[i]):\n",
    "        if item == 0:\n",
    "            strat_0.append(strat_tr[i][j])\n",
    "        elif item == 1:\n",
    "            strat_1.append(strat_tr[i][j])\n",
    "        elif item == 2:\n",
    "            strat_2.append(strat_tr[i][j])\n",
    "\n",
    "print(len(strat_0), len(strat_1), len(strat_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bee678ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.11962023 0.14346766 0.11602822 0.12275441 0.13734565 0.10130471\n",
      " 0.1300965  0.12938263] [0.42894168 0.17817303 0.07215742 0.06545482 0.05932482 0.05118508\n",
      " 0.07555469 0.06920846] [0.57228889 0.18950889 0.05327873 0.0403331  0.02379078 0.03050997\n",
      " 0.04997504 0.04031457]\n"
     ]
    }
   ],
   "source": [
    "ms_0 = np.mean(np.array(strat_0), 0)\n",
    "ms_1 = np.mean(np.array(strat_1), 0)\n",
    "ms_2 = np.mean(np.array(strat_2), 0)\n",
    "print(ms_0, ms_1, ms_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "908c2e08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "data_2d = np.vstack([ms_0, ms_1, ms_2])\n",
    "\n",
    "\n",
    "# Create the heatmap\n",
    "plt.figure(figsize=(8, 4))  # Adjust the size as needed\n",
    "sns.heatmap(data_2d, cmap=\"coolwarm\", vmin=0, vmax=0.6, yticklabels=[\"Attackers\", \"Bystanders\", \"Supporters\"])  # Choose a colormap that fits your data\n",
    "# viridis, , annot=True\n",
    "# Optional: Add labels, title, etc.\n",
    "plt.title(\"Distribution of Users' Strategies within Different Groups\", size=15)\n",
    "plt.xlabel(\"Strategies\", size=15)#\n",
    "#plt.ylabel(\"Row\")\n",
    "plt.tick_params(axis='y', labelsize=12)\n",
    "\n",
    "# Display the heatmap\n",
    "plt.tight_layout()\n",
    "plt.savefig('../result/heatmap_jiayangfan.png', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea4c6ee3",
   "metadata": {},
   "outputs": [],
   "source": [
    "scale = [1, 1e3, 1e3, 1e3, 1e3, 1e3, 1e3, 1e3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c8e9e91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9.98642266e-01, 1.07979611e-04, 4.87784740e-04, 2.11293217e-04,\n",
       "       6.35078437e-05, 2.71009480e-04, 1.48113032e-04, 6.80406926e-05])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean(np.array(strat_0), 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b89ca27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9.97384846e-01, 2.43167975e-04, 8.06368771e-04, 3.80310346e-04,\n",
       "       1.42341363e-04, 4.99840535e-04, 3.45563923e-04, 1.97667410e-04])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean(np.array(strat_1), 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ead55141",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9.99011886e-01, 8.78300398e-05, 3.19675852e-04, 1.41030914e-04,\n",
       "       4.80180978e-05, 1.94500281e-04, 1.27388699e-04, 6.96790908e-05])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean(np.array(strat_2), 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58edc676",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = range(8)\n",
    "plt.plot(x, np.mean(np.array(strat_0), 0), label='Attacker')\n",
    "plt.plot(x, np.mean(np.array(strat_1), 0), label='Bystander')\n",
    "plt.plot(x, np.mean(np.array(strat_2), 0), label='Supporter')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bfd4a5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "target_u = []\n",
    "pred_u = []\n",
    "strat_u = []\n",
    "\n",
    "mask_u = []\n",
    "true_labels = []\n",
    "for i, item in enumerate(test):\n",
    "    mask_u.append(item.masks)\n",
    "    true_labels.append(item.labels)\n",
    "\n",
    "for i in range(len(mask_u)):\n",
    "    for j in range(len(mask_u[i])):\n",
    "        mask_temp = sum(mask_u[i][j])\n",
    "        pred_u.append(pred_test[i][j][:mask_temp])\n",
    "        target_u.append(true_labels[i][j][:mask_temp].tolist())\n",
    "        strat_t = strat_test[i][j][:mask_temp]\n",
    "        strat_u.append(strat_t)\n",
    "\n",
    "strat_0 = []\n",
    "strat_1 = []\n",
    "strat_2 = []\n",
    "\n",
    "for i, item in enumerate(target_u):\n",
    "    for j in range(len(item)):\n",
    "        if item[j] == 0:\n",
    "            strat_0.append(strat_u[i][j])\n",
    "        elif item[j] == 1:\n",
    "            strat_1.append(strat_u[i][j])\n",
    "        else:\n",
    "            strat_2.append(strat_u[i][j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1082ff53",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e779990",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5266884b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e8db8f6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "777fa063",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78ff3a2e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05093096",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dc9b5b2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37b49f98",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17b371bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5dee0108",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39867066",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1939fea0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36ed57de",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b860d43",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5653da2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c30ddc0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6ce1d2e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a97211ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "out_dir = '../data/JiayangFan'\n",
    "journalist = 'JiayangFan'\n",
    "with open(os.path.join(out_dir, f'{journalist}_dict.pkl'), 'rb') as f:\n",
    "    data = pickle.load(f)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}_ids.pkl'), 'rb') as f:\n",
    "    map_id = pickle.load(f)\n",
    "    \n",
    "with open(os.path.join(out_dir, f'{journalist}_lan.pkl'), 'rb') as f:\n",
    "    map_lan = pickle.load(f)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}_type.pkl'), 'rb') as f:\n",
    "    map_type = pickle.load(f)\n",
    "\n",
    "with open(os.path.join(out_dir, f'{journalist}_reply.pkl'), 'rb') as f:\n",
    "    map_reply = pickle.load(f)\n",
    "\n",
    "alice = pd.DataFrame.from_dict(data)\n",
    "alice_sort = alice.sort_values(by=['created_at'])\n",
    "conv = pd.read_csv(os.path.join(out_dir, f'{journalist}_conv_labels.csv'))\n",
    "\n",
    "data = pkl.load(open(os.path.join(out_dir, f'{journalist}_dict.pkl'), 'rb'))\n",
    "journal = pd.DataFrame.from_dict(data)\n",
    "journal_sort = pd.read_csv(os.path.join(out_dir, f'{journalist}_conv_labels.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88c1ae12",
   "metadata": {},
   "outputs": [],
   "source": [
    "short_gap = []\n",
    "for item in journal_sort['time gap']:\n",
    "    if item < 240:\n",
    "        short_gap.append(item)\n",
    "        \n",
    "max_gap = 240\n",
    "data = []\n",
    "# for index, item in journal_sort.iterrows():\n",
    "#     data.append(superbeta.pdf(1-item['time gap'] / max_gap) + 1e-20)\n",
    "for item in short_gap:\n",
    "    data.append(superbeta.pdf(1 - item / max_gap) + 1e-10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2bafe082",
   "metadata": {},
   "outputs": [],
   "source": [
    "ids = list(set(journal_sort['conversation_id']))\n",
    "batch_data = []\n",
    "target_data = []\n",
    "conv_data = []\n",
    "ref_data = []\n",
    "id_data = []\n",
    "for idx in ids:\n",
    "    convs = journal_sort[journal_sort['conversation_id'] == idx]\n",
    "    convs_batch = convs[[\"type\", \"possibly_sensitive\", \"lang\", \"reply_settings\",\n",
    "                     \"retweet_count\", \"reply_count\", \"like_count\", \"quote_count\", \"impression_count\",\n",
    "                     \"mentions\", \"urls\"]]\n",
    "    conv_data.append(list(convs['conversation_id']))\n",
    "    ref_data.append(list(convs['reference_id']))\n",
    "    id_data.append(list(convs['tweet_id']))\n",
    "    batch_data.append(convs_batch.values.tolist())\n",
    "    target_data.append(list(convs['labels']))\n",
    "    \n",
    "label_data = target_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "a6292f35",
   "metadata": {},
   "outputs": [],
   "source": [
    "contexts = []\n",
    "for item in conv['context']:\n",
    "    temp_s = ''\n",
    "    if item == '0':\n",
    "        contexts.append('Unified Twitter Taxonomy')\n",
    "\n",
    "    else:\n",
    "        for i in ast.literal_eval(item):\n",
    "            temp_s  += (i['domain']['name'] + ' ' + i['entity']['name'])\n",
    "        contexts.append(temp_s)\n",
    "    \n",
    "annotations = []\n",
    "for item in conv['annotations']:\n",
    "    temp_s = ''\n",
    "    if item == '0':\n",
    "        annotations.append('Others')\n",
    "\n",
    "    else:\n",
    "        for i in ast.literal_eval(item):\n",
    "            temp_s += i['type'] + ' ' + i['normalized_text']\n",
    "\n",
    "        annotations.append(temp_s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "id": "ab438d99",
   "metadata": {},
   "outputs": [],
   "source": [
    "journal['context'] = contexts\n",
    "journal['annotations'] = annotations\n",
    "journal_sort = journal.sort_values(by=['created_at'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "id": "8f424c4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## topics\n",
    "## people\n",
    "ref_ids = []\n",
    "\n",
    "journal_sort['topics'] = None\n",
    "journal_sort['ppls'] = None\n",
    "conv_ids = set(journal_sort['conversation_id'])\n",
    "for conv in list(conv_ids):\n",
    "    test_d = journal_sort[journal_sort['conversation_id'] == conv]\n",
    "    for index, item in test_d.iterrows():\n",
    "        i = 0\n",
    "        tweet_id = item['tweet_id']\n",
    "        ref_id = item['reference_id']\n",
    "        conv_id = item['conversation_id']\n",
    "        topic1 = item['context']\n",
    "        anno1 = item['annotations']\n",
    "        if len(test_d) == 1:\n",
    "            topic2 = 'Unified Twitter Taxonomy'\n",
    "            anno2 = 'Others'\n",
    "            journal_sort.at[index, 'topics']=[text1, text2]\n",
    "            journal_sort.at[index, 'ppls']=[anno1, anno2]\n",
    "            continue\n",
    "        if ref_id not in ref_ids:\n",
    "            if tweet_id == test_d.iloc[0]['tweet_id']:\n",
    "                text2 = test_d[test_d['tweet_id']==test_d.iloc[1]['tweet_id']]['context'].item()\n",
    "                anno2 = test_d[test_d['tweet_id']==test_d.iloc[1]['tweet_id']]['annotations'].item()\n",
    "            else:\n",
    "                text2 = test_d.iloc[i-1]['context']\n",
    "                anno2 = test_d.iloc[i-1]['annotations']\n",
    "        else:\n",
    "            #print(tweet_id,ref_id)\n",
    "            text2 = test_d[test_d['tweet_id']==ref_id]['context'].item()\n",
    "            anno2 = test_d[test_d['tweet_id']==ref_id]['annotations'].item()\n",
    "\n",
    "        ref_ids.append(tweet_id)\n",
    "        \n",
    "        journal_sort.at[index, 'topics']=[text1, text2]\n",
    "        journal_sort.at[index, 'ppls']=[anno1, anno2]\n",
    "        #print(text2, journal_sort.at[index, 'topics'])\n",
    "        i += 1\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "3f634ddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "journal_sort.to_csv(os.path.join(out_dir, f'{journalist}_context.csv'), index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "id": "692dbdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "10632it [17:00, 10.41it/s]\n"
     ]
    }
   ],
   "source": [
    "context_sims = []\n",
    "\n",
    "# Initialize tokenizer and model\n",
    "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
    "model = BertModel.from_pretrained('bert-base-uncased')\n",
    "for index, item in tqdm(journal_sort.iterrows()):\n",
    "    # Tokenize input text and convert to tensor\n",
    "    c1 = item['topics'][0]\n",
    "    c2 = item['topics'][1]\n",
    "    \n",
    "    a1 = item['ppls'][0]\n",
    "    a2 = item['ppls'][1]\n",
    "    inputs1 = tokenizer(c1, return_tensors=\"pt\")\n",
    "    inputs2 = tokenizer(c2, return_tensors=\"pt\")\n",
    "\n",
    "    # Generate embeddings\n",
    "    with torch.no_grad():\n",
    "        outputs1 = model(**inputs1)\n",
    "        outputs2 = model(**inputs2)\n",
    "\n",
    "    # The last hidden state is the sequence of hidden states of the last layer of the model\n",
    "    last_hidden_states1 = outputs1.last_hidden_state\n",
    "    last_hidden_states2 = outputs2.last_hidden_state\n",
    "\n",
    "    # Optionally, use the [CLS] token's embedding as the representation for the entire sentence\n",
    "    sentence_embedding1 = last_hidden_states1[:, 0, :]\n",
    "    sentence_embedding2 = last_hidden_states2[:, 0, :]\n",
    "\n",
    "    cosine = np.dot(sentence_embedding1,sentence_embedding2.T)/(norm(sentence_embedding1)*norm(sentence_embedding2))\n",
    "    context_sims.append(cosine)\n",
    "    #print(sentence_embedding.shape)\n",
    "    \n",
    "journal_sort['topics_sim'] = context_sims"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "id": "da53ee76",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "10632it [13:57, 12.70it/s]\n"
     ]
    }
   ],
   "source": [
    "# Initialize tokenizer and model\n",
    "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
    "model = BertModel.from_pretrained('bert-base-uncased')\n",
    "anno_sims = []\n",
    "for index, item in tqdm(journal_sort.iterrows()):\n",
    "    # Tokenize input text and convert to tensor\n",
    "    c1 = item['topics'][0]\n",
    "    c2 = item['topics'][1]\n",
    "    \n",
    "    a1 = item['ppls'][0]\n",
    "    a2 = item['ppls'][1]\n",
    "    inputs1 = tokenizer(a1, return_tensors=\"pt\")\n",
    "    inputs2 = tokenizer(a2, return_tensors=\"pt\")\n",
    "\n",
    "    # Generate embeddings\n",
    "    with torch.no_grad():\n",
    "        outputs1 = model(**inputs1)\n",
    "        outputs2 = model(**inputs2)\n",
    "\n",
    "    # The last hidden state is the sequence of hidden states of the last layer of the model\n",
    "    last_hidden_states1 = outputs1.last_hidden_state\n",
    "    last_hidden_states2 = outputs2.last_hidden_state\n",
    "\n",
    "    # Optionally, use the [CLS] token's embedding as the representation for the entire sentence\n",
    "    sentence_embedding1 = last_hidden_states1[:, 0, :]\n",
    "    sentence_embedding2 = last_hidden_states2[:, 0, :]\n",
    "\n",
    "    cosine = np.dot(sentence_embedding1,sentence_embedding2.T)/(norm(sentence_embedding1)*norm(sentence_embedding2))\n",
    "    anno_sims.append(cosine)\n",
    "    #print(sentence_embedding.shape)\n",
    "    \n",
    "journal_sort['ppls_sim'] = anno_sims\n",
    "journal_sort = pd.read_csv(os.path.join(out_dir, f'{journalist}_context.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "id": "6033f78f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "034022e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "anchor_time = []\n",
    "test_d = journal_sort[journal_sort['conversation_id']==4]\n",
    "for index, item in test_d.iterrows():\n",
    "    anchor_time.append(datetime.strptime(item['created_at'][:19], date_format))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c3c17c75",
   "metadata": {},
   "outputs": [],
   "source": [
    "anchor = anchor_time[1] - anchor_time[0]\n",
    "anchor_hours = divmod(anchor.total_seconds() , 3600)[0]  # 1"
   ]
  },
  {
   "cell_type": "raw",
   "id": "941a8f68",
   "metadata": {},
   "source": [
    "date_format = \"%Y-%m-%dT%H:%M:%S\" \n",
    "datetime.strptime(data[0]['created_at'][:19], date_format)\n",
    "journal_sort.at[0, 'created_at'] - journal_sort.at[4, 'created_at']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7e097cd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "## time\n",
    "from datetime import datetime\n",
    "ref_ids = []\n",
    "date_format = \"%Y-%m-%dT%H:%M:%S\" \n",
    "journal_sort['time gap'] = None\n",
    "conv_ids = set(journal_sort['conversation_id'])\n",
    "for conv in list(conv_ids):\n",
    "    test_d = journal_sort[journal_sort['conversation_id'] == conv]\n",
    "    time0 = datetime.strptime(test_d.iloc[0]['created_at'][:19], date_format)\n",
    "    k = 0\n",
    "    for index, item in test_d.iterrows():\n",
    "        tweet_id = item['tweet_id']\n",
    "        ref_id = item['reference_id']\n",
    "        conv_id = item['conversation_id']\n",
    "        time1 = datetime.strptime(item['created_at'][:19], date_format)\n",
    "        if len(test_d) == 1:\n",
    "            journal_sort.at[index, 'time gap']= float(anchor_hours) #/120\n",
    "            continue\n",
    "        if ref_id not in ref_ids:\n",
    "            if tweet_id == test_d.iloc[0]['tweet_id']:\n",
    "                time2 = datetime.strptime(item['created_at'][:19], date_format) - anchor\n",
    "            else:\n",
    "                time2 = datetime.strptime(test_d.iloc[k-1]['created_at'][:19], date_format)\n",
    "        else:\n",
    "            #print(test_d[test_d['tweet_id']==ref_id]['created_at'][:19].item())\n",
    "            time2 = datetime.strptime(test_d[test_d['tweet_id']==ref_id]['created_at'].item()[:19], date_format)\n",
    "    \n",
    "\n",
    "        ref_ids.append(tweet_id)\n",
    "        gap_in_s = (time1 - time2).total_seconds() \n",
    "        journal_sort.at[index, 'time gap']= float(divmod(gap_in_s, 3600)[0]) #/ 120\n",
    "        \n",
    "        k += 1\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867368df",
   "metadata": {},
   "outputs": [],
   "source": [
    "## PA * Latest * Field * Self = 2*2*2*2 = 16\n",
    "## PA: Normal PA (p=0.1, p/#nodes + (1-p)indegree/sum_of_indegree), Uniform (1/#nodes)\n",
    "## Latest: Normal Latest (beta(10,1), x=1-(outyear-inyear)/(outyear-oldest_year)), Uniform (1/(outyear-oldest_year))\n",
    "## Field: Similar (1-(1-e^(-||x-y||_2))/(1-e^(-2)), x&y L2-normalized), Different ((1-e^(-||x-y||_2))/(1-e^(-2)), x&y L2-normalized)\n",
    "## Self: Prefer (coauthors: 0.9/#coauthors, non-coauthors: 0.1/#non-coauthors), Not Prefer (coauthors: 0.1/#coauthors, non-coauthors: 0.9/#non-coauthors)\n",
    "\n",
    "## 1st: Normal_PA * Normal_Latest * Similar_Field * Prefer_Self\n",
    "## 2nd: Normal_PA * Normal_Latest * Similar_Field * NotPrefer_Self\n",
    "## 3rd: Normal_PA * Normal_Latest * Different_Field * Prefer_Self\n",
    "## 4th: Normal_PA * Normal_Latest * Different_Field * NotPrefer_Self\n",
    "## 5th: Normal_PA * Uniform_Latest * Similar_Field * Prefer_Self\n",
    "## 6th: Normal_PA * Uniform_Latest * Similar_Field * NotPrefer_Self\n",
    "## 7th: Normal_PA * Uniform_Latest * Different_Field * Prefer_Self\n",
    "## 8th: Normal_PA * Uniform_Latest * Different_Field * NotPrefer_Self\n",
    "## 9th: Uniform_PA * Normal_Latest * Similar_Field * Prefer_Self\n",
    "## 10th: Uniform_PA * Normal_Latest * Similar_Field * NotPrefer_Self\n",
    "## 11th: Uniform_PA * Normal_Latest * Different_Field * Prefer_Self\n",
    "## 12th: Uniform_PA * Normal_Latest * Different_Field * NotPrefer_Self\n",
    "## 13th: Uniform_PA * Uniform_Latest * Similar_Field * Prefer_Self\n",
    "## 14th: Uniform_PA * Uniform_Latest * Similar_Field * NotPrefer_Self\n",
    "## 15th: Uniform_PA * Uniform_Latest * Different_Field * Prefer_Self\n",
    "## 16th: Uniform_PA * Uniform_Latest * Different_Field * NotPrefer_Self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ea209ebc",
   "metadata": {},
   "outputs": [],
   "source": [
    "superbeta = beta(a=10,b=1)\n",
    "\n",
    "# def cal_cite_edgeprobs(df):\n",
    "#     edge_prob = []\n",
    "#     for index, item in df.iterrows():\n",
    "         \n",
    "#         ppl_sim = float(item['ppls_sim'][2:-2])\n",
    "#         ppl_dif = 1 - ppl_sim\n",
    "\n",
    "#         topic_sim = float(item['topics_sim'][2:-2])\n",
    "#         topic_dif = 1 - topic_sim\n",
    "\n",
    "#         pnormal_latest = superbeta.pdf(1-item['time gap']) + 1e-20\n",
    "#         puniform_latest = 1 / 168\n",
    "\n",
    "#         temp1 = np.array([ppl_sim, ppl_dif])\n",
    "#         temp2 = np.outer([topic_sim,topic_dif],[pnormal_latest,puniform_latest]).flatten()\n",
    "#         result = np.outer(temp1,temp2).flatten()\n",
    "#         edge_prob.append(result)\n",
    "    \n",
    "#     return np.array(edge_prob, dtype=np.float32)\n",
    "def cal_cite_edgeprobs(ids):\n",
    "    edge_prob = [] #np.zeros((len(ids), 8))\n",
    "    for idx in ids:\n",
    "        convs = journal_sort[journal_sort['conversation_id'] == idx]\n",
    "        temp = []\n",
    "        max_gap = 240 # max(convs['time gap'])\n",
    "        for index, item in convs.iterrows():\n",
    "\n",
    "            ppl_sim = float(item['ppls_sim'][2:-2])\n",
    "            ppl_dif = 1 - ppl_sim\n",
    "\n",
    "            topic_sim = float(item['topics_sim'][2:-2]) - 1e-3\n",
    "            topic_dif = 1 - topic_sim\n",
    "\n",
    "            pnormal_latest = (superbeta.pdf(1-item['time gap'] / max_gap) + 1e-10) / 10\n",
    "            puniform_latest = 1 / 120\n",
    "\n",
    "            temp1 = np.array([ppl_sim, ppl_dif])\n",
    "            temp2 = np.outer([topic_sim,topic_dif],[pnormal_latest,puniform_latest]).flatten()\n",
    "            result = np.outer(temp1,temp2).flatten()\n",
    "            temp.append(result)\n",
    "        edge_prob.append(np.array(temp))\n",
    "    return edge_prob\n",
    "edgeprob = cal_cite_edgeprobs(ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0667dd98",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(out_dir, f'{journalist}_edgeprob.pkl'),'wb') as f:\n",
    "    pickle.dump(edgeprob, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "51563449",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join(out_dir, f'{journalist}_edgeprob.pkl'),'rb') as f:\n",
    "    edgeprob = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc0891cb",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}