gen_payoff.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 337,
   "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",
    "\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": 3,
   "id": "590c2652",
   "metadata": {},
   "outputs": [],
   "source": [
    "## People\n",
    "## Time\n",
    "## Topic\n",
    "## Media Contents\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 598,
   "id": "69cd3410",
   "metadata": {},
   "outputs": [],
   "source": [
    "out_dir = '../data'\n",
    "data_dir = '../data'\n",
    "journalist = 'muyixiao'\n",
    "batch_size = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 599,
   "id": "da562edf",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 16/16 [00:00<00:00, 16202.04it/s]\n",
      "100%|██████████| 16/16 [00:00<00:00, 9721.70it/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 = [12, 16]\n",
    "# JiayangFan: 80: 84\n",
    "# muyixiao: 12: 16\n",
    "# lingling: 98, 99\n",
    "# alice: 100, 150\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",
    "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": 600,
   "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": 601,
   "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 tid not in label_id.keys():\n",
    "        journal_sort.loc[index, 'labels'] = 1\n",
    "    else: \n",
    "        journal_sort.loc[index, 'labels'] = label_id[tid]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 602,
   "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": 603,
   "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": 604,
   "id": "a2f680ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "journal = conv['author_id'][0]\n",
    "conv['utility_a'] = None\n",
    "conv['utility_b'] = None\n",
    "conv['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.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",
    "        if row['labels'] == 0:\n",
    "            attacked = len(refer[refer['labels']==2]) + len(refer[refer['labels']==1])\n",
    "        else:\n",
    "            attacked = len(refer[refer['labels']==0]) + 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.loc[index, 'utility_a'] = utility_a\n",
    "    conv.loc[index, 'utility_b'] = utility_b\n",
    "    conv.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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 605,
   "id": "a8a3e2e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 606,
   "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",
    "sorted_dict = {'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": 533,
   "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, pickle_file)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 548,
   "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] \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": 551,
   "id": "f1ba8455",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31 6.237929565040203\n",
      "1970 25.87273024701456\n",
      "240 29.47543765714043\n",
      "5797 69.82885085574573\n",
      "13 0.1177047572339382\n",
      "4996 32.931605602660206\n",
      "348 0.3902439024390244\n",
      "======\n",
      "31 0.027783405203600266\n",
      "1970 0.3926380368098159\n",
      "240 0.7079646017699115\n",
      "5797 5.353159851301116\n",
      "13 0.0\n",
      "4996 0.18334606569900688\n",
      "348 0.1951219512195122\n",
      "======\n",
      "31 0.013891702601800133\n",
      "1970 0.05239602663464687\n",
      "240 0.05901155642980084\n",
      "5797 0.05223636957231472\n",
      "13 0.0\n",
      "4996 0.23357664233576644\n",
      "348 0.025884383088869714\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": 552,
   "id": "e2f1d696",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': [0.527685156866969,\n",
       "  0.16696968193614986,\n",
       "  1.6827044503455757,\n",
       "  0.13238463217781368,\n",
       "  0.010602868957726682,\n",
       "  0.06163436914344921,\n",
       "  0.005436084304544172],\n",
       " 'b': [0.0015284400439466443,\n",
       "  0.0029786323078753248,\n",
       "  0.003578353164063416,\n",
       "  0.007248280192625641,\n",
       "  0.0,\n",
       "  0.0009693802733898417,\n",
       "  0.0013620226660278501],\n",
       " 'c': [0.0004481194387677462,\n",
       "  0.0002943686124466576,\n",
       "  0.0003152729222208325,\n",
       "  0.00023342530178280236,\n",
       "  0.0,\n",
       "  0.0005853387368363964,\n",
       "  0.00030251180068450475]}"
      ]
     },
     "execution_count": 552,
     "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": 596,
   "id": "ca34f98a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': {0: 0.527685156866969, 1: 0.16696968193614986, 2: 1.6827044503455757, 3: 0.13238463217781368, 4: 0.010602868957726682, 5: 0.06163436914344921, 7: 0.005436084304544172}, 'b': {0: 0.0015284400439466443, 1: 0.0029786323078753248, 2: 0.003578353164063416, 3: 0.007248280192625641, 4: 0.0, 5: 0.0009693802733898417, 7: 0.0013620226660278501}, 'c': {0: 0.0004481194387677462, 1: 0.0002943686124466576, 2: 0.0003152729222208325, 3: 0.00023342530178280236, 4: 0.0, 5: 0.0005853387368363964, 7: 0.00030251180068450475}}\n",
      "0.012094064949608062\n"
     ]
    }
   ],
   "source": [
    "scale = 1\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 * 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",
    "        mean[ind][k] = np.mean(v)\n",
    "print(mean)\n",
    "\n",
    "c = 0\n",
    "total_len = 0\n",
    "for k, v in sorted_scale['a'].items():\n",
    "    total_len += len(v)\n",
    "    for item in v:\n",
    "        if item >= 1.68:\n",
    "            c += 1\n",
    "print(c / total_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "id": "18256a52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.027783405203600266\n",
      "0.3926380368098159\n",
      "0.7079646017699115\n",
      "5.353159851301116\n",
      "0.0\n",
      "0.18334606569900688\n",
      "0.1951219512195122\n"
     ]
    }
   ],
   "source": [
    "for ind, item in sorted_scale['b'].items():\n",
    "    print(max(item))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "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., 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_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.2094] * 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": 594,
   "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_all['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.05] * 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": 597,
   "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.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_all['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.04] * 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 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": "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",
      "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
}