visualize_v3.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import gc\n",
    "import torch\n",
    "import warnings\n",
    "import numpy as np\n",
    "import scipy.stats\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm\n",
    "from copy import deepcopy\n",
    "import plotly.express as px\n",
    "import matplotlib.pyplot as plt\n",
    "import plotly.graph_objects as go\n",
    "from utils.python_utils import dotdict, alpha_sort\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "sns.set_theme(style=\"white\", rc={\"axes.facecolor\": (0, 0, 0, 0)})\n",
    "if sns.__version__ != '0.12.1': raise NotImplementedError"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "version = '3.1'\n",
    "\n",
    "history_dir = os.path.join('history','v'+version)\n",
    "base_dir = os.path.join('docs','visuals','v'+version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Supporting Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "subset=''\n",
    "history={}\n",
    "history_dict={}\n",
    "\n",
    "# Make save directory\n",
    "def make_save_dir(history):\n",
    "    dataset = history['config']['main_dataset']\n",
    "\n",
    "    strategy = history['strategy'] if history['config']['labeled_sampling']=='equal' else 'random_'+history['strategy']\n",
    "    run = history['config']['run_name']\n",
    "    config_str = '_'.join(history['file_name'].split('_')[0:5])\n",
    "    \n",
    "    plots_dir = os.path.join(base_dir,dataset,strategy,run,config_str)\n",
    "    os.makedirs(plots_dir,exist_ok=True)\n",
    "\n",
    "    return plots_dir\n",
    "\n",
    "# Class labels\n",
    "class_labels = {'dbpedia_14':{0:'Company', 1:'Edu Institution', 2:'Artist', 3:'Athlete', 4:'Office Holder',5:'Mean Of Trans', 6:'Building',\\\n",
    "                              7:'Natural Place', 8:'Village', 9:'Animal', 10:'Plant', 11:'Album', 12:'Film', 13:'Written Work'},\n",
    "                'yahoo_answers':{0:\"Society\", 1:\"Science\", 2:\"Health\", 3:\"Education\", 4:\"Computers\",\\\n",
    "                                    5:\"Sports\", 6:\"Business\", 7:\"Music\", 8:\"Family\", 9:\"Politics\"}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Load History Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Consolidate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "history_dict = dict()\n",
    "\n",
    "for dataset in os.listdir(history_dir):\n",
    "    dataset_path = os.path.join(history_dir,dataset)\n",
    "    if os.path.isdir(dataset_path):\n",
    "        for run in os.listdir(dataset_path):\n",
    "            run_path = os.path.join(dataset_path,run)\n",
    "            if os.path.isdir(run_path):\n",
    "                \n",
    "                if dataset in history_dict: history_dict[dataset][run] = []\n",
    "                else: history_dict[dataset] = {run:[]}\n",
    "                \n",
    "                for path, dirs, files in os.walk(run_path):\n",
    "                    for file_ in files:\n",
    "                        if file_[-10:] == 'history.pt' and dirs:\n",
    "                            try:\n",
    "                                history_dict[dataset][run].append(torch.load(os.path.join(run_path,file_)))\n",
    "                                history_dict[dataset][run][-1]['file_name'] = file_\n",
    "                            except:\n",
    "                                print(dataset,run,file_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_path = os.path.join(history_dir,'consolidated_history.pt')\n",
    "torch.save(history_dict,save_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_path = os.path.join(history_dir,'consolidated_history.pt')\n",
    "history_dict = dotdict(torch.load(save_path))\n",
    "history_dict.datasets = list(history_dict.keys())\n",
    "history_dict.runs = [list(history_dict[dataset].keys()) for dataset in history_dict.datasets]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets  : ['yahoo_answers']\n",
      "Runs: [['Run1', 'Run2', 'Run3', 'Run4', 'Run5']]\n",
      "\n",
      "History keys: dict_keys(['strategy', 'config', 'iteration', 'batch_size', 'epoch', 'train_loss', 'train_acc', 'val_loss', 'val_cw_f1', 'val_acc', 'val_cw_acc', 'test_loss', 'test_cw_f1', 'test_acc', 'test_cw_acc', 'labeled_set_size', 'unlabeled_set_size', 'selected_set_size', 'selected_in_domain', 'selected_out_domain', 'train_distribution', 'labeled_distribution', 'unlabeled_distribution', 'selected_distribution', 'predicted_distribution', 'pseudo_distribution', 'predicted_probs', 'predicted_prob_mean', 'predicted_prob_std', 'predicted_prob_max', 'predicted_prob_min', 'selected_probs', 'selected_prob_mean', 'selected_prob_std', 'selected_prob_max', 'selected_prob_min', 'file_name'])\n",
      "\n",
      "Config keys : dict_keys(['run_name', 'strategy', 'strategy_value', 'main_dataset', 'other_datasets', 'main_sampling_ratio', 'labeled_size', 'labeled_sampling', 'unlabeled_size', 'unlabeled_in_domain_ratio', 'eval_size', 'num_epochs', 'num_iters', 'max_batch_size', 'min_batch_size', 'steps_per_epoch', 'min_total_steps', 'max_patience', 'save_interval', 'sorted_data', 'history_dir', 'data_dir', 'cache_dir', 'resume_from'])\n",
      "\n",
      "File Counts:\n",
      "\n",
      "Dataset: yahoo_answers\n",
      "20 Run1\n",
      "20 Run2\n",
      "19 Run3\n",
      "19 Run4\n",
      "20 Run5\n"
     ]
    }
   ],
   "source": [
    "print('Datasets  :',history_dict.datasets)\n",
    "print('Runs:',history_dict.runs)\n",
    "print('\\nHistory keys:', history_dict[history_dict.datasets[0]][history_dict.runs[0][0]][0].keys())\n",
    "print('\\nConfig keys :', history_dict[history_dict.datasets[0]][history_dict.runs[0][0]][0]['config'].keys())\n",
    "\n",
    "print('\\nFile Counts:')\n",
    "for dataset in history_dict.datasets:\n",
    "    print('\\nDataset:', dataset)\n",
    "    for run, val in history_dict[dataset].items():\n",
    "        print(len(val), run)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Plots for each run"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### 3.1 Probability Distribution Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Supporting Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to label the plot in axes coordinates\n",
    "def prob_label(x, color, label):\n",
    "    ax = plt.gca()\n",
    "    \n",
    "    ax.text(0.05, .3, str(int(label)+1), fontsize='small',#color=color,# fontweight=\"bold\",\n",
    "        ha=\"left\", va=\"center\", transform=ax.transAxes)\n",
    "    min_ = '%.2f  '  %(history[subset+'_prob_min'][int(label)])\n",
    "    max_ = '%.2f    '%(history[subset+'_prob_max'][int(label)])\n",
    "    std  = '%.2f   ' %(history[subset+'_prob_std'][int(label)])\n",
    "    mean = '%.2f'    %(history[subset+'_prob_mean'][int(label)])\n",
    "    stat = min_+max_+std+mean\n",
    "    ax.text(1, .3, stat, fontsize='small',#color=color,# fontweight=\"bold\",\n",
    "        ha=\"left\", va=\"center\", transform=ax.transAxes)\n",
    "\n",
    "# Function to label the plot in axes coordinates\n",
    "def sel_prob_label(x, color, label):\n",
    "    ax = plt.gca()\n",
    "    \n",
    "    ax.text(0.05, .3, str(int(label)+1), fontsize='small',#color=color,# fontweight=\"bold\",\n",
    "        ha=\"left\", va=\"center\", transform=ax.transAxes)\n",
    "    min_ = '%.2f  '  %(history['selected_prob_min'][int(label)])\n",
    "    max_ = '%.2f    '%(history['selected_prob_max'][int(label)])\n",
    "    std  = '%.2f   ' %(history['selected_prob_std'][int(label)])\n",
    "    mean = '%.2f'    %(history['selected_prob_mean'][int(label)])\n",
    "    stat = min_+max_+std+mean\n",
    "    ax.text(1, .3, stat, fontsize='small',#color=color,# fontweight=\"bold\",\n",
    "        ha=\"left\", va=\"center\", transform=ax.transAxes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset  : yahoo_answers\n",
      "Strategy : pc_top_k\n",
      "Run      : Run4\n",
      "Indices  : [0]\n",
      "Unique   : [20]\n",
      "Iter Lens: [20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "dataset = history_dict.datasets[0]\n",
    "run = history_dict.runs[0][3]\n",
    "history_list = history_dict[dataset][run]\n",
    "\n",
    "iter_lens = [len(history['iteration']) for history in history_list]\n",
    "sorted_ = sorted(list(set(iter_lens)))\n",
    "indices = [iter_lens.index(val) for val in sorted_]\n",
    "print('Dataset  :', dataset)\n",
    "print('Strategy :', history_list[0]['strategy'])\n",
    "print('Run      :', run)\n",
    "print('Indices  :', indices)\n",
    "print('Unique   :', sorted_)\n",
    "print('Iter Lens:', iter_lens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "hl = history_dict['yahoo_answers']['Run1']\n",
    "history = None\n",
    "for his in hl:\n",
    "    ls = his['config']['labeled_size']\n",
    "    ubr = his['config']['unlabeled_in_domain_ratio']\n",
    "    if ls==1000 and ubr ==0.5: history=his"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history['config']['labeled_size']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices =  [3]\n",
    "subset = 'selected' # selected , predicted\n",
    "\n",
    "for index in indices:\n",
    "    # Load Probs from history\n",
    "    history = history_list[index]\n",
    "\n",
    "    # Make a dataframe to plot\n",
    "    probs = []\n",
    "    iterations = []\n",
    "    for itr, prob_list in enumerate(history[subset+'_probs']):\n",
    "        probs += list(prob_list)\n",
    "        iterations += ([itr]*len(prob_list))\n",
    "    df = pd.DataFrame(dict(probability=probs, iteration=iterations))\n",
    "\n",
    "    # Set size to ensure same width\n",
    "    iterations = len(history['iteration'])\n",
    "    height = 0.5\n",
    "    # width = (0.001 * iterations) + 6 if iterations > 15 else (0.001 * iterations) + 4.4\n",
    "    aspect = 12 if iterations > 22 else 8.2\n",
    "\n",
    "    # Initialize the FacetGrid object\n",
    "    grid = sns.FacetGrid(df, row=\"iteration\", hue=\"iteration\", aspect=aspect, height=height,\n",
    "        sharey=False, sharex=True, palette=sns.color_palette(\"husl\", len(history['iteration'])))\n",
    "\n",
    "    # Plot the densities\n",
    "    # line_color = {'selected':'black', 'predicted':'white'}\n",
    "    line_width = {'selected':1, 'predicted':1.5}\n",
    "    # grid.map(sns.kdeplot, \"probability\", fill=False, alpha = 1,color = line_color[subset], lw=line_width[subset], clip_on=False)\n",
    "    grid.map(sns.kdeplot, \"probability\", fill=False, alpha = 1,color = 'black', lw=1, clip_on=False)\n",
    "    grid.map(sns.kdeplot, \"probability\", fill=True, alpha = 1, lw = 1.2,clip_on=False)\n",
    "\n",
    "    # Passing color=None to refline() uses the hue mapping\n",
    "    grid.refline(y=-0, linewidth=0.3, linestyle=\"-\", color=None, clip_on=False)\n",
    "\n",
    "    # Set labels\n",
    "    grid.map(prob_label, \"probability\")\n",
    "\n",
    "    # Set the subplots to overlap\n",
    "    grid.figure.subplots_adjust(hspace=-.15)\n",
    "\n",
    "    # Set axes details\n",
    "    grid.set_titles(\"\")\n",
    "    grid.set(yticks=[], ylabel=\"\")\n",
    "    grid.despine(bottom=True, left=True)\n",
    "    plt.xticks([0.2,0.4,0.6,0.8,1.0], fontsize='small')\n",
    "\n",
    "    # Set headings\n",
    "    plt.suptitle(subset.title()+\" Probability Distribution\",fontsize='large', y = 1.005)\n",
    "    plt.text(0,.8,\"Iteration\",transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "    plt.text(1,.8,\"Min  Max  STD  Mean\",transform=plt.gcf().get_axes()[0].transAxes,fontdict={'fontsize':'medium'})\n",
    "\n",
    "    # # Plot\n",
    "    # name = 'ls_'+str(history['config']['labeled_size'])+'_idr_'+str(history['config']['unlabeled_in_domain_ratio'])+\\\n",
    "    #     '_'+subset+'_prob_dist_v'+version+'.svg'\n",
    "    # plt.savefig(name,bbox_inches='tight');\n",
    "    plt.show();\n",
    "    \n",
    "#########################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Yahoo_Answers, Run5, Predicted: 100%|██████████| 20/20 [04:13<00:00, 12.69s/it]\n"
     ]
    }
   ],
   "source": [
    "datasets = history_dict.datasets\n",
    "# runs = history_dict.runs[0]\n",
    "runs = ['Run5']\n",
    "subsets = ['predicted'] #selected\n",
    "for dataset in datasets:\n",
    "    for run in runs:\n",
    "        history_list = history_dict[dataset][run]\n",
    "        for subset in subsets:\n",
    "            for history in tqdm(history_list, desc=dataset.title()+', '+run.title()+', '+subset.title()):\n",
    "                # Make save dir\n",
    "                plots_dir = make_save_dir(history)\n",
    "                \n",
    "                # Make a dataframe to plot\n",
    "                probs = []\n",
    "                iterations = []\n",
    "                for itr, prob_list in enumerate(history[subset+'_probs']):\n",
    "                    probs += list(prob_list)\n",
    "                    iterations += ([itr]*len(prob_list))\n",
    "                df = pd.DataFrame(dict(probability=probs, iteration=iterations))\n",
    "\n",
    "                # Set size to ensure same width\n",
    "                iterations = len(history['iteration'])\n",
    "                height = 0.5\n",
    "                aspect = 12 if iterations > 22 else 8.2\n",
    "\n",
    "                # Initialize the FacetGrid object\n",
    "                grid = sns.FacetGrid(df, row=\"iteration\", hue=\"iteration\", aspect=aspect, height=height,\n",
    "                    sharey=False, sharex=True, palette=sns.color_palette(\"husl\", len(history['iteration'])))\n",
    "\n",
    "                # Plot the densities\n",
    "                line_color = {'selected':'black', 'predicted':'white'}\n",
    "                line_width = {'selected':1, 'predicted':1.5}\n",
    "                # grid.map(sns.kdeplot, \"probability\", fill=False, alpha = 1,color = line_color[subset], lw=line_width[subset], clip_on=False)\n",
    "                grid.map(sns.kdeplot, \"probability\", fill=False, alpha = 1,color = 'black', lw=1, clip_on=False)\n",
    "                grid.map(sns.kdeplot, \"probability\", fill=True, alpha = 1, lw = 1.2, clip_on=False)\n",
    "\n",
    "                # Passing color=None to refline() uses the hue mapping\n",
    "                grid.refline(y=-0, linewidth=0.3, linestyle=\"-\", color=None, clip_on=False)\n",
    "\n",
    "                # Set labels\n",
    "                grid.map(prob_label, \"probability\")\n",
    "\n",
    "                # Set the subplots to overlap\n",
    "                grid.figure.subplots_adjust(hspace=-.15)\n",
    "\n",
    "                # Set axes details\n",
    "                grid.set_titles(\"\")\n",
    "                grid.set(yticks=[], ylabel=\"\")\n",
    "                grid.despine(bottom=True, left=True)\n",
    "                plt.xticks([0.2,0.4,0.6,0.8,1.0], fontsize='small')\n",
    "\n",
    "                # Set headings\n",
    "                plt.suptitle(subset.title()+\" Probability Distribution\",fontsize='large',x=0.55, y = 1.005)\n",
    "                plt.text(0,.8,\"Iteration\",transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "                plt.text(1,.8,\"Min  Max  STD  Mean\",transform=plt.gcf().get_axes()[0].transAxes,fontdict={'fontsize':'medium'})\n",
    "\n",
    "                # Save\n",
    "                # plt.savefig(plots_dir+'/'+config_str+' '+subset+\"_prob_dist.png\",bbox_inches=\"tight\");\n",
    "                plt.savefig(plots_dir+'/'+subset+\"_prob_dist.png\",bbox_inches=\"tight\");\n",
    "                plt.clf();\n",
    "                plt.close('all');\n",
    "                del(df)\n",
    "                del(history)\n",
    "                del(grid)\n",
    "                gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### 3.2 Class Distribution Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Supporting Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to label the plot in axes coordinates\n",
    "def class_label(x, color, label):\n",
    "    ax = plt.gca()\n",
    "    if subset.lower() == 'selected':\n",
    "        txt = history['selected_set_size'][int(label)]\n",
    "        in_do = ' '*(3-len(str(txt)))+'   '+str(history['selected_in_domain'][int(label)]) +' '*(3-len(str(history['selected_in_domain'][int(label)])))\n",
    "        out_do = '   '+str(history['selected_out_domain'][int(label)])\n",
    "        txt = str(txt) + in_do + out_do\n",
    "    elif subset.lower() == 'labeled' or subset.lower() == 'train':\n",
    "        txt = history['labeled_set_size'][int(label)]\n",
    "    elif subset.lower() == 'unlabeled' or subset.lower() == 'predicted':\n",
    "        txt = history['unlabeled_set_size'][int(label)]\n",
    "    elif subset.lower() == 'pseudo':\n",
    "        txt = history['selected_set_size'][int(label)]\n",
    "    else: raise NotImplementedError\n",
    "    \n",
    "    ax.text(-0.15, .2, str(int(label)+1), fontsize='small', ha=\"left\", va=\"center\", transform=ax.transAxes)\n",
    "    ax.text(1.05, .2, str(txt), fontsize='small', ha=\"left\", va=\"center\", transform=ax.transAxes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset  : yahoo_answers\n",
      "Strategy : pc_top_k\n",
      "Run      : Run1\n",
      "Subset   : selected\n",
      "Indices  : [0]\n",
      "\n",
      "Unique   : ('20 4', 0)\n",
      "\n",
      "Iter Lens: ['20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4', '20 4']\n"
     ]
    }
   ],
   "source": [
    "dataset = history_dict.datasets[0]\n",
    "run = history_dict.runs[0][0]\n",
    "history_list = history_dict[dataset][run]\n",
    "\n",
    "subset = 'selected'      # 'train', 'predicted', 'selected', Not maintained anymore - 'pseudo', 'labeled', 'unlabeled'\n",
    "\n",
    "iter_lens = [str(len(history[subset.lower()+'_distribution']))+' '+str(len(history[subset.lower()+'_distribution'][0])) for history in history_list]\n",
    "sorted_ = alpha_sort(list(set(iter_lens)))\n",
    "sorted_ = sorted(list(set(iter_lens)))\n",
    "indices = [iter_lens.index(val) for val in sorted_]\n",
    "print('Dataset  :', dataset)\n",
    "print('Strategy :', history_list[0]['strategy'])\n",
    "print('Run      :', run)\n",
    "print('Subset   :', subset)\n",
    "print('Indices  :', indices)\n",
    "print('\\nUnique   :', *zip(sorted_,indices))\n",
    "print('\\nIter Lens:', iter_lens)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 175x1000 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "indices = [0]\n",
    "\n",
    "for index in indices:\n",
    "    # Load distribution from history\n",
    "    history = history_list[index]\n",
    "\n",
    "    # Make a dataframe to plot\n",
    "    classes = []\n",
    "    datasets = []\n",
    "    count = []\n",
    "    total = []\n",
    "    iteration = []\n",
    "\n",
    "    if subset == 'selected': \n",
    "        for itr, dist in enumerate(history[subset.lower()+'_distribution']):\n",
    "            dist = {key:sum(value.values()) for key,value in dist.items()}\n",
    "            datasets += [' '.join(class_.split('_')).title() for class_ in dist.keys()]\n",
    "            count += list(dist.values())\n",
    "            total += [sum(value.values()) for value in history['unlabeled_distribution'][itr].values()]\n",
    "            iteration += [itr]*len(list(dist.keys()))\n",
    "        df = pd.DataFrame(dict(datasets=datasets, count=count, total=total, iteration=iteration))\n",
    "    else: \n",
    "        for itr, dist in enumerate(history[subset.lower()+'_distribution']):\n",
    "            classes += list(dist.keys())\n",
    "            count += list(dist.values())\n",
    "            iteration += [itr]*len(list(dist.keys()))\n",
    "        df = pd.DataFrame(dict(classes=classes, count=count, iteration=iteration))\n",
    "\n",
    "\n",
    "    # Initialize the FacetGrid object\n",
    "    iterations  = len(history[subset.lower() + '_distribution'])\n",
    "    class_count = len(history[subset.lower() + '_distribution'][0])\n",
    "\n",
    "    if dataset == 'dbpedia_14':\n",
    "        if subset == 'selected':\n",
    "            if class_count == 14: aspect = 12 if iterations > 22 else 9\n",
    "            else: aspect = 7.8 if iterations > 21 else 4.5\n",
    "        elif subset == 'pseudo' or subset == 'predicted':\n",
    "            aspect = 6.5 if iterations > 21 else 4.5\n",
    "        else:\n",
    "            if class_count == 14: aspect = 11   \n",
    "            else: aspect = 6.6 if iterations > 15 else 4.5\n",
    "    elif dataset == 'yahoo_answers':\n",
    "        if subset == 'selected':\n",
    "            if class_count == 10: \n",
    "                if iterations > 21: aspect = 10\n",
    "                elif iterations > 15: aspect = 6\n",
    "                else: aspect = 6\n",
    "            else: \n",
    "                if iterations > 21: aspect = 6.8 \n",
    "                elif iterations > 15: aspect = 3.5\n",
    "                else: aspect= 3.3\n",
    "        elif subset == 'pseudo':\n",
    "            if iterations > 21: aspect = 5.1  \n",
    "            elif iterations > 15: aspect = 6\n",
    "            else: aspect = 3.3\n",
    "        elif subset == 'predicted':\n",
    "            if iterations > 21: aspect = 5.7\n",
    "            elif iterations > 15: aspect = 6\n",
    "            else: aspect = 3.3\n",
    "        else: \n",
    "            if iterations > 21: aspect = 5.7\n",
    "            elif iterations > 15: aspect = 6\n",
    "            else: aspect = 3.3\n",
    "    else: raise NotImplementedError\n",
    "    \n",
    "    # Set size to ensure same width\n",
    "    height = 0.5\n",
    "    grid = sns.FacetGrid(df, row=\"iteration\", hue=\"iteration\", aspect=aspect, height=height,\\\n",
    "        sharey=False if subset=='selected' else False, sharex=True, palette=sns.color_palette(\"husl\", iterations))\n",
    "\n",
    "    # Draw the densities in a few steps\n",
    "    if subset=='selected':\n",
    "        grid.map(sns.barplot, 'datasets', 'total', errorbar=None, alpha=0.5, clip_on=False)    \n",
    "        grid.map(sns.barplot, 'datasets', 'count', errorbar=None, clip_on=False)\n",
    "    else: grid.map(sns.barplot, 'classes', 'count', errorbar=None, clip_on=False)\n",
    "        \n",
    "    # Passing color=None to refline() uses the hue mapping\n",
    "    grid.refline(y=0, linewidth=0.5, linestyle=\"-\", color=None, clip_on=False)\n",
    "\n",
    "    # Set labels\n",
    "    if subset == 'selected': grid.map(class_label, \"datasets\")\n",
    "    else: grid.map(class_label, \"classes\")\n",
    "\n",
    "    # Set the subplots to overlap\n",
    "    grid.figure.subplots_adjust(hspace=-.005)\n",
    "\n",
    "    # Set axes details\n",
    "    grid.set_titles(\"\")\n",
    "    grid.set(yticks=[], ylabel=\"\")\n",
    "    grid.despine(bottom=True, left=True)\n",
    "\n",
    "    # Set headings\n",
    "    if subset=='selected': \n",
    "        plt.xticks(rotation='vertical')\n",
    "        plt.suptitle(subset.title()+\" Set Class Distribution\", fontsize='large', x=0.82, y=1.005)\n",
    "    else: \n",
    "        ticks = list(history[subset.lower()+'_distribution'][0].keys())\n",
    "        labels = [class_labels[dataset][tick] for tick in ticks]\n",
    "        plt.xticks(ticks,labels=labels,rotation='vertical')\n",
    "        plt.suptitle(subset.title()+\" Set Class Distribution\", fontsize='large', x=0.5, y=1.005)\n",
    "\n",
    "    plt.text(-0.15,1,\"Iteration\", transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "    if subset =='selected': plt.text(1.05,1,'Size  In  Out', transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "    else: plt.text(1.05,1,'Size', transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "\n",
    "    # Plot\n",
    "    # plt.savefig('ztest/'+str(iterations)+'_'+subset,bbox_inches=\"tight\")\n",
    "    # name = 'ls_'+str(history['config']['labeled_size'])+'_idr_'+str(history['config']['unlabeled_in_domain_ratio'])+\\\n",
    "    #        '_'+subset+'_class_dist_v'+version+'.svg'\n",
    "    # plt.savefig(name,bbox_inches='tight');\n",
    "    plt.show();\n",
    "  ##\n",
    "###################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Yahoo_Answers, Run1, Predicted: 100%|██████████| 20/20 [01:21<00:00,  4.08s/it]\n",
      "Yahoo_Answers, Run1, Selected: 100%|██████████| 20/20 [01:20<00:00,  4.03s/it]\n",
      "Yahoo_Answers, Run1, Pseudo: 100%|██████████| 20/20 [01:21<00:00,  4.09s/it]\n",
      "Yahoo_Answers, Run2, Predicted: 100%|██████████| 20/20 [01:22<00:00,  4.11s/it]\n",
      "Yahoo_Answers, Run2, Selected: 100%|██████████| 20/20 [01:21<00:00,  4.06s/it]\n",
      "Yahoo_Answers, Run2, Pseudo: 100%|██████████| 20/20 [01:23<00:00,  4.15s/it]\n",
      "Yahoo_Answers, Run3, Predicted: 100%|██████████| 19/19 [01:17<00:00,  4.10s/it]\n",
      "Yahoo_Answers, Run3, Selected: 100%|██████████| 19/19 [01:16<00:00,  4.03s/it]\n",
      "Yahoo_Answers, Run3, Pseudo: 100%|██████████| 19/19 [01:17<00:00,  4.08s/it]\n",
      "Yahoo_Answers, Run4, Predicted: 100%|██████████| 19/19 [01:18<00:00,  4.13s/it]\n",
      "Yahoo_Answers, Run4, Selected: 100%|██████████| 19/19 [01:17<00:00,  4.07s/it]\n",
      "Yahoo_Answers, Run4, Pseudo: 100%|██████████| 19/19 [01:18<00:00,  4.12s/it]\n",
      "Yahoo_Answers, Run5, Predicted: 100%|██████████| 20/20 [01:22<00:00,  4.12s/it]\n",
      "Yahoo_Answers, Run5, Selected: 100%|██████████| 20/20 [01:21<00:00,  4.07s/it]\n",
      "Yahoo_Answers, Run5, Pseudo: 100%|██████████| 20/20 [01:22<00:00,  4.14s/it]\n"
     ]
    }
   ],
   "source": [
    "# ['pseudo', 'labeled', 'unlabeled', 'train', 'predicted', 'selected']\n",
    "datasets = history_dict.datasets\n",
    "runs = history_dict.runs[0]\n",
    "subsets = ['predicted','selected','pseudo']# 'train',# 'pseudo','predicted','selected']\n",
    "for dataset in datasets:\n",
    "    for run in runs:\n",
    "        history_list = history_dict[dataset][run]\n",
    "        for subset in subsets:\n",
    "            for history in tqdm(history_list, desc=dataset.title()+', '+run.title()+', '+subset.title()):\n",
    "\n",
    "                # Make save dir\n",
    "                plots_dir = make_save_dir(history)\n",
    "\n",
    "                # Make a dataframe to plot\n",
    "                classes = []\n",
    "                datasets = []\n",
    "                count = []\n",
    "                total = []\n",
    "                iteration = []\n",
    "\n",
    "                if subset == 'selected': \n",
    "                    for itr, dist in enumerate(history[subset.lower()+'_distribution']):\n",
    "                        dist = {key:sum(value.values()) for key,value in dist.items()}\n",
    "                        datasets += [' '.join(class_.split('_')).title() for class_ in dist.keys()]\n",
    "                        count += list(dist.values())\n",
    "                        total += [sum(value.values()) for value in history['unlabeled_distribution'][itr].values()]\n",
    "                        iteration += [itr]*len(list(dist.keys()))\n",
    "                    df = pd.DataFrame(dict(datasets=datasets, count=count, total=total, iteration=iteration))\n",
    "                else: \n",
    "                    for itr, dist in enumerate(history[subset.lower()+'_distribution']):\n",
    "                        classes += list(dist.keys())\n",
    "                        count += list(dist.values())\n",
    "                        iteration += [itr]*len(list(dist.keys()))\n",
    "                    df = pd.DataFrame(dict(classes=classes, count=count, iteration=iteration))\n",
    "\n",
    "\n",
    "                # Initialize the FacetGrid object\n",
    "                iterations  = len(history[subset.lower() + '_distribution'])\n",
    "                class_count = len(history[subset.lower() + '_distribution'][0])\n",
    "\n",
    "                if dataset == 'dbpedia_14':\n",
    "                    if subset == 'selected':\n",
    "                        if class_count == 14: aspect = 12 if iterations > 22 else 9\n",
    "                        else: aspect = 7.8 if iterations > 21 else 4.5\n",
    "                    elif subset == 'pseudo' or subset == 'predicted':\n",
    "                        aspect = 6.5 if iterations > 21 else 4.5\n",
    "                    else:\n",
    "                        if class_count == 14: aspect = 11   \n",
    "                        else: aspect = 6.6 if iterations > 15 else 4.5\n",
    "                elif dataset == 'yahoo_answers':\n",
    "                    if subset == 'selected':\n",
    "                        if class_count == 10: \n",
    "                            if iterations > 21: aspect = 10\n",
    "                            elif iterations > 15: aspect = 6\n",
    "                            else: aspect = 6\n",
    "                        else: \n",
    "                            if iterations > 21: aspect = 6.8 \n",
    "                            elif iterations > 15: aspect = 3.5\n",
    "                            else: aspect= 3.3\n",
    "                    elif subset == 'pseudo':\n",
    "                        if iterations > 21: aspect = 5.1  \n",
    "                        elif iterations > 15: aspect = 6\n",
    "                        else: aspect = 3.3\n",
    "                    elif subset == 'predicted':\n",
    "                        if iterations > 21: aspect = 5.7\n",
    "                        elif iterations > 15: aspect = 6\n",
    "                        else: aspect = 3.3\n",
    "                    else: \n",
    "                        if iterations > 21: aspect = 5.7\n",
    "                        elif iterations > 15: aspect = 6\n",
    "                        else: aspect = 3.3\n",
    "                else: raise NotImplementedError\n",
    "                \n",
    "                # Set size to ensure same width\n",
    "                height = 0.5\n",
    "                grid = sns.FacetGrid(df, row=\"iteration\", hue=\"iteration\", aspect=aspect, height=height,\\\n",
    "                    sharey=False if subset=='selected' else False, sharex=True, palette=sns.color_palette(\"husl\", iterations))\n",
    "\n",
    "                # Draw the densities in a few steps\n",
    "                if subset=='selected':\n",
    "                    grid.map(sns.barplot, 'datasets', 'total', errorbar=None, alpha=0.5, clip_on=False)    \n",
    "                    grid.map(sns.barplot, 'datasets', 'count', errorbar=None, clip_on=False)\n",
    "                else: grid.map(sns.barplot, 'classes', 'count', errorbar=None, clip_on=False)\n",
    "                    \n",
    "                # Passing color=None to refline() uses the hue mapping\n",
    "                grid.refline(y=0, linewidth=0.5, linestyle=\"-\", color=None, clip_on=False)\n",
    "\n",
    "                # Set labels\n",
    "                if subset == 'selected': grid.map(class_label, \"datasets\")\n",
    "                else: grid.map(class_label, \"classes\")\n",
    "\n",
    "                # Set the subplots to overlap\n",
    "                grid.figure.subplots_adjust(hspace=-.005)\n",
    "\n",
    "                # Set axes details\n",
    "                grid.set_titles(\"\")\n",
    "                grid.set(yticks=[], ylabel=\"\")\n",
    "                grid.despine(bottom=True, left=True)\n",
    "\n",
    "                # Set headings\n",
    "                if subset=='selected': \n",
    "                    plt.xticks(rotation='vertical')\n",
    "                    plt.suptitle(subset.title()+\" Set Class Distribution\", fontsize='large', x=0.82, y=1.005)\n",
    "                else: \n",
    "                    ticks = list(history[subset.lower()+'_distribution'][0].keys())\n",
    "                    labels = [class_labels[dataset][tick] for tick in ticks]\n",
    "                    plt.xticks(ticks,labels=labels,rotation='vertical')\n",
    "                    plt.suptitle(subset.title()+\" Set Class Distribution\", fontsize='large', x=0.5, y=1.005)\n",
    "\n",
    "                plt.text(-0.15,1,\"Iteration\", transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "                if subset =='selected': plt.text(1.05,1,'Size  In  Out', transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "                else: plt.text(1.05,1,'Size', transform=plt.gcf().get_axes()[0].transAxes, fontdict={'fontsize':'medium'})\n",
    "\n",
    "\n",
    "                # Save\n",
    "                plt.savefig(plots_dir+'/'+subset+\"_set_class_dist.png\",bbox_inches=\"tight\");\n",
    "                plt.clf();\n",
    "                plt.close('all');\n",
    "                del(df)\n",
    "                del(history)\n",
    "                del(grid)\n",
    "                gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Metric plots"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Supporting Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stats(data, confidence=0.95):\n",
    "    a = 1.0 * np.array(data)\n",
    "    n = len(a)\n",
    "    mean, sem = np.mean(a), scipy.stats.sem(a)\n",
    "    ci = sem * scipy.stats.t.ppf((1 + confidence) / 2., n-1)\n",
    "    return mean, ci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Accuracy Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict(color='LightSkyBlue', line=dict(color='MediumPurple', width=2), size=10, symbol='circle'),\n",
    "markers = {0.05:dict(size=6, symbol='circle'),\n",
    "           0.25:dict(size=6, symbol='square'),\n",
    "           0.5:dict(size=6, symbol='x'),\n",
    "           0.75:dict(size=6, symbol='diamond-tall'),\n",
    "           1:dict(size=6, symbol='star')}\n",
    "\n",
    "#            Blue                  Red                   Green                 Yellow                Purple\n",
    "#            Dark       Light      Dark       Light      Dark       Light      Dark       Light      Dark       Light\n",
    "# colors = ['#1e74ae', '#7cbde9', '#cd181b', '#f28c8e', '#34a02c', '#a2d973', '#cb8e01', '#fdd068', '#7141a4', '#af8ac1']\n",
    "colors = {'min_max' :{100:'rgba(124, 189, 233,0.2)', 500:'rgba(242, 140, 142, 0.2)', 1000:'rgba(162, 217, 115, 0.2)', 5000 :'rgba(175, 138, 193, 0.2)'},#, 2500:'#fdd068'\n",
    "          'avg'     :{100:'#1e74ae', 500:'#cd181b', 1000:'#34a02c', 5000 :'#7141a4'}}#, 2500:'#cb8e01'\n",
    "\n",
    "runs = history_dict.runs[0]\n",
    "for dataset in history_dict.datasets:\n",
    "    fig = go.Figure()\n",
    "\n",
    "    # Legend Keys    \n",
    "    # in_domain_ratio\n",
    "    for key,value in markers.items():\n",
    "        fig.add_trace(\n",
    "            go.Scatter(\n",
    "                mode='markers',\n",
    "                x = [None],\n",
    "                y = [None],\n",
    "                # line = dict(width=value,color='black'),\n",
    "                name = str(int(key*100))+'%',\n",
    "                legendgroup='in_domain_ratio',\n",
    "                legendgrouptitle_text='In Domain Ratio (IDR)',\n",
    "                marker = dict(size=10,symbol=value['symbol'],color='black'),\n",
    "            ))\n",
    "\n",
    "    # labeled_size\n",
    "    for key,value in colors['avg'].items():\n",
    "        fig.add_trace(\n",
    "            go.Scatter(\n",
    "                mode='lines',\n",
    "                x = [None],\n",
    "                y = [None],\n",
    "                line = dict(width=4,color=value,dash='solid'),\n",
    "                name = str(key),\n",
    "                legendgroup='labeled_size',\n",
    "                legendgrouptitle_text='Labeled Size (LS)',\n",
    "            ))\n",
    "\n",
    "    #configs\n",
    "    config_names = [hs['file_name'] for hs in history_dict[dataset][runs[0]]]\n",
    "    sorted_config_names = alpha_sort(config_names)\n",
    "    sorted_idx = [config_names.index(name) for name in sorted_config_names]\n",
    "    for idx in sorted_idx:\n",
    "        history = history_dict[dataset][runs[0]][idx]\n",
    "        if history['config']['unlabeled_in_domain_ratio'] in markers.keys():\n",
    "            config = '_'.join(history['file_name'].split('_')[0:5])\n",
    "\n",
    "            # Get same config history from other runs\n",
    "            history_list = [history]\n",
    "            for run in runs[1:]:\n",
    "                for hs in history_dict[dataset][run]:\n",
    "                    hs_config = '_'.join(hs['file_name'].split('_')[0:5])\n",
    "                    if hs_config == config:\n",
    "                        history_list.append(hs)\n",
    "        \n",
    "            # Get Params\n",
    "            labeled_size = history['config']['labeled_size']\n",
    "            in_domain_ratio = history['config']['unlabeled_in_domain_ratio']\n",
    "\n",
    "            # Get number of max iterations\n",
    "            itrs = 0\n",
    "            for hs in history_list:\n",
    "                if len(hs['iteration']) > itrs: itrs = len(hs['iteration'])\n",
    "\n",
    "            # Accumulate Test Accuracies\n",
    "            test_accs = []\n",
    "            for itr in range(itrs):\n",
    "                test_accs.append([])\n",
    "                for hs in history_list:\n",
    "                    try: test_accs[-1].append(hs['test_acc'][itr][0])\n",
    "                    except: \n",
    "                        try: test_accs[-1].append(hs['test_acc'][itr])\n",
    "                        except: pass\n",
    "\n",
    "            mean_accs = []\n",
    "            max_accs = []\n",
    "            min_accs = []\n",
    "            std_accs = []\n",
    "            ci_accs= []\n",
    "\n",
    "            for accs in test_accs:\n",
    "                mean, ci = get_stats(accs)\n",
    "                mean_accs.append(mean)\n",
    "                ci_accs.append(ci)\n",
    "                max_accs.append(np.max(accs))\n",
    "                min_accs.append(np.min(accs))\n",
    "                std_accs.append(np.std(accs))\n",
    "\n",
    "            std_up = np.array(mean_accs)+np.array(std_accs)\n",
    "            std_dwn = np.array(mean_accs)-np.array(std_accs)\n",
    "\n",
    "            ci_up = np.array(mean_accs)+np.array(ci_accs)\n",
    "            ci_dwn = np.array(mean_accs)-np.array(ci_accs)\n",
    "\n",
    "            itrs = [*range(1,len(mean_accs)+1)]\n",
    "            \n",
    "            fig.add_trace(\n",
    "                go.Scatter(\n",
    "                    mode='lines+markers',\n",
    "                    x =itrs,\n",
    "                    y = mean_accs,\n",
    "                    line = dict(color=colors['avg'][labeled_size]),\n",
    "                    name = 'LS '+str(labeled_size)+'; IDR '+str(int(in_domain_ratio*100))+'%',\n",
    "                    legendgroup='ls_idr',\n",
    "                    legendgrouptitle_text=\"Labeled Size, In Domain Ratio\",\n",
    "                    marker = markers[in_domain_ratio],\n",
    "                )\n",
    "            )\n",
    "            fig.add_trace(\n",
    "                go.Scatter(\n",
    "                    x=itrs+itrs[::-1],\n",
    "                    y=np.concatenate((ci_up,ci_dwn[::-1])),\n",
    "                    fill='toself',\n",
    "                    fillcolor=colors['min_max'][labeled_size],\n",
    "                    line_color=colors['min_max'][labeled_size],\n",
    "                    legendgroup='ls_idr_ci',\n",
    "                    legendgrouptitle_text=\"95% Confidence Interval\",\n",
    "                    name = 'LS '+str(labeled_size)+'; IDR '+str(int(in_domain_ratio*100))+'%',\n",
    "                )\n",
    "            )\n",
    "            fig.add_trace(\n",
    "                go.Scatter(\n",
    "                    x=itrs+itrs[::-1],\n",
    "                    y=np.concatenate((std_up,std_dwn[::-1])),\n",
    "                    fill='toself',\n",
    "                    fillcolor=colors['min_max'][labeled_size],\n",
    "                    line_color=colors['min_max'][labeled_size],\n",
    "                    legendgroup='ls_idr_std',\n",
    "                    legendgrouptitle_text=\"STD Range\",\n",
    "                    name = 'LS '+str(labeled_size)+'; IDR '+str(int(in_domain_ratio*100))+'%',\n",
    "                )\n",
    "            )\n",
    "            fig.add_trace(\n",
    "                go.Scatter(\n",
    "                    x=itrs+itrs[::-1],\n",
    "                    y=max_accs+min_accs,\n",
    "                    fill='toself',\n",
    "                    fillcolor=colors['min_max'][labeled_size],\n",
    "                    line_color=colors['min_max'][labeled_size],\n",
    "                    legendgroup='ls_idr_mnmx',\n",
    "                    legendgrouptitle_text=\"Min-Max Range\",\n",
    "                    name = 'LS '+str(labeled_size)+'; IDR '+str(int(in_domain_ratio*100))+'%',\n",
    "                )\n",
    "            )\n",
    "            \n",
    "            \n",
    "    fig.update_layout(\n",
    "    legend=dict(\n",
    "            font=dict(size=13,color=\"black\"),\n",
    "            groupclick=\"toggleitem\",\n",
    "            itemdoubleclick='toggleothers',\n",
    "            grouptitlefont=dict(size=15,color='black')\n",
    "        ),\n",
    "        title=dict(text='Accuracy Plot',font=dict(size=25)),\n",
    "        font=dict(size=15),\n",
    "        template='plotly_white')\n",
    "    fig.update_xaxes(title_text='iteration')\n",
    "    fig.update_yaxes(title_text='accuracy')\n",
    "    fig.write_html(os.path.join(base_dir,dataset,history['strategy'],\"acc_comparison.html\"),auto_open=False)\n",
    "    # fig.write_html('test.html',auto_open=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mean Acc for LS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls_list = [100,500,1000,5000]\n",
    "in_domain_ratio_list = [0.05,0.25,0.75,1.0]\n",
    "\n",
    "plot_dir = os.path.join(base_dir,dataset,history_dict[history_dict.datasets[0]][history_dict.runs[0][0]][0]['strategy'],'Avg_Plots')\n",
    "os.makedirs(plot_dir,exist_ok=True)\n",
    "\n",
    "for dataset in history_dict.datasets:\n",
    "    data_dict = {}\n",
    "    for run,histories in history_dict[dataset].items():\n",
    "        for his in histories:\n",
    "            ls = his['config']['labeled_size']\n",
    "            idr = his['config']['unlabeled_in_domain_ratio']\n",
    "            if ls in data_dict: \n",
    "                if idr in data_dict[ls]: data_dict[ls][idr].append(his)\n",
    "                else: data_dict[ls][idr]=[his]\n",
    "            else: \n",
    "                data_dict[ls]={idr:[his]}\n",
    "    \n",
    "    # Set figure\n",
    "    fig, ax = plt.subplots(2, 2,figsize=(12,6))\n",
    "   \n",
    "    axes = np.array(ax).flatten()\n",
    "    sns.set_style('whitegrid')\n",
    "\n",
    "    for (ls, ls_dict), ax in zip(data_dict.items(),axes):\n",
    "        itrs = []\n",
    "        test_accs = []\n",
    "        idr_list = []\n",
    "        for idr in in_domain_ratio_list:\n",
    "            histories = ls_dict[idr]\n",
    "            \n",
    "            for his in histories:\n",
    "                accs = []\n",
    "                for acc in his['test_acc']:\n",
    "                    try: accs.append(acc[0])\n",
    "                    except: \n",
    "                        try: accs.append(acc)\n",
    "                        except: pass\n",
    "                test_accs+=accs[1:]\n",
    "                itrs+=his['iteration'][1:]\n",
    "                idr_list += ([idr]*len(his['iteration'][1:]))\n",
    "\n",
    "        df = pd.DataFrame(dict(Itr=itrs, Acc=test_accs,IDR=idr_list))\n",
    "        \n",
    "        # Plot the lines\n",
    "        sns.lineplot(df ,x='Itr',y='Acc', hue='IDR',dashes=False,markers='o',palette=sns.color_palette(\"husl\",len(in_domain_ratio_list)),ax=ax)   \n",
    "        # Adjust border\n",
    "        sns.despine(top=True,right=True)\n",
    "\n",
    "        # Set Labels, legends and ticks\n",
    "        ax.set_title('Labeled Size: '+str(ls))\n",
    "        ax.set_xlabel(\"\")\n",
    "        ax.set_ylabel(\"\")\n",
    "        ax.legend(facecolor=\"w\")#,loc=4,title='IDR')\n",
    "        ax.set_xticks([*range(2,21,2)],labels=[*range(2,21,2)])\n",
    "        ax.set_xlim(1,24.6)\n",
    "   \n",
    "    # Plot\n",
    "    axes[-1].set_xlabel(\"Iteration\")\n",
    "    axes[-2].set_xlabel(\"Iteration\")\n",
    "    axes[0].set_ylabel(\"Accuracy\")\n",
    "    axes[2].set_ylabel(\"Accuracy\")\n",
    "    plt.tight_layout()\n",
    "    # plt.show();\n",
    "\n",
    "    plt.savefig(os.path.join(plot_dir,'accuracy_plot_'+version+'.png'),bbox_inches=\"tight\");\n",
    "    plt.savefig(os.path.join(plot_dir,'accuracy_plot_'+version+'.svg'),bbox_inches=\"tight\");\n",
    "    plt.clf();\n",
    "    plt.close('all');"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Avg Selection Percentage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ls_list = [100,500,1000,5000]\n",
    "in_domain_ratio_list = [0.05,0.25,0.75,1.0]\n",
    "\n",
    "plot_dir = os.path.join(base_dir,dataset,history_dict[history_dict.datasets[0]][history_dict.runs[0][0]][0]['strategy'],'Avg_Plots')\n",
    "\n",
    "os.makedirs(plot_dir,exist_ok=True)\n",
    "\n",
    "for dataset in history_dict.datasets:\n",
    "    data_dict = {}\n",
    "    for run,histories in history_dict[dataset].items():\n",
    "        for his in histories:\n",
    "            ls = his['config']['labeled_size']\n",
    "            idr = his['config']['unlabeled_in_domain_ratio']\n",
    "            if ls in data_dict: \n",
    "                if idr in data_dict[ls]: data_dict[ls][idr].append(his)\n",
    "                else: data_dict[ls][idr]=[his]\n",
    "            else: \n",
    "                data_dict[ls]={idr:[his]}\n",
    "    \n",
    "\n",
    "    # Set figure\n",
    "    fig, ax = plt.subplots(2, 2,figsize=(12,6))\n",
    "   \n",
    "    axes = np.array(ax).flatten()\n",
    "    sns.set_style('whitegrid')\n",
    "    \n",
    "    for (ls, ls_dict), ax in zip(data_dict.items(),axes):\n",
    "        itrs = []\n",
    "        in_pcs = []\n",
    "        idr_list = []\n",
    "\n",
    "        for idr in in_domain_ratio_list:\n",
    "            histories = ls_dict[idr]\n",
    "            for his in histories:\n",
    "                in_pc = (np.array(his['selected_in_domain'])/np.array(his['selected_set_size'])).tolist()\n",
    "                in_pcs += in_pc\n",
    "                # out_pcs += (np.array(his['selected_out_domain'])/np.array(his['selected_set_size'])).tolist()\n",
    "                itrs+=[*range(1,len(in_pc)+1)]\n",
    "                idr_list += ([idr]*len(in_pc))\n",
    "\n",
    "        df = pd.DataFrame(dict(Itr=itrs, ratio=in_pcs,IDR=idr_list))\n",
    "        \n",
    "        # Plot the lines\n",
    "        sns.lineplot(df ,x='Itr',y='ratio', hue='IDR',dashes=False,markers='o',palette=sns.color_palette(\"husl\",len(in_domain_ratio_list)),ax=ax)        # Adjust border\n",
    "        # Adjust border\n",
    "        sns.despine(top=True,right=True)\n",
    "\n",
    "        # Set Labels, legends and ticks\n",
    "        ax.set_title('Labeled Size: '+str(ls))\n",
    "        ax.set_xlabel(\"\")\n",
    "        ax.set_ylabel(\"\")\n",
    "        ax.legend(facecolor=\"w\")#,loc=4,title='IDR')\n",
    "        ax.set_xticks([*range(2,21,2)],labels=[*range(2,21,2)])\n",
    "        ax.set_xlim(1,24.6)\n",
    "    \n",
    "    # Plot\n",
    "    axes[-1].set_xlabel(\"Iteration\")\n",
    "    axes[-2].set_xlabel(\"Iteration\")\n",
    "    axes[0].set_ylabel(\"In-Domain Selection Ratio\")\n",
    "    axes[2].set_ylabel(\"In-Domain Selection Ratio\")\n",
    "    plt.tight_layout()\n",
    "    # plt.show();\n",
    "\n",
    "    plt.savefig(os.path.join(plot_dir,'selection_plot_'+version+'.png'),bbox_inches=\"tight\");\n",
    "    plt.savefig(os.path.join(plot_dir,'selection_plot_'+version+'.svg'),bbox_inches=\"tight\");\n",
    "    plt.clf();\n",
    "    plt.close('all');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### Accuracy for each Config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset  : yahoo_answers\n",
      "Strategy : pc_top_k\n",
      "Run      : Run1\n",
      "Indices  : [0]\n",
      "Unique   : [20]\n",
      "Iter Lens: [20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "dataset = history_dict.datasets[0]\n",
    "run = history_dict.runs[0][0]\n",
    "history_list = history_dict[dataset][run]\n",
    "\n",
    "iter_lens = [len(history['iteration']) for history in history_list]\n",
    "sorted_ = sorted(list(set(iter_lens)))\n",
    "indices = [iter_lens.index(val) for val in sorted_]\n",
    "print('Dataset  :', dataset)\n",
    "print('Strategy :', history_list[0]['strategy'])\n",
    "print('Run      :', run)\n",
    "print('Indices  :', indices)\n",
    "print('Unique   :', sorted_)\n",
    "print('Iter Lens:', iter_lens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'float' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb Cell 48\u001b[0m in \u001b[0;36m<cell line: 9>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=6'>7</a>\u001b[0m max_idx \u001b[39m=\u001b[39m [his\u001b[39m.\u001b[39mindex(acc) \u001b[39mfor\u001b[39;00m his, acc \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(history[\u001b[39m'\u001b[39m\u001b[39mval_acc\u001b[39m\u001b[39m'\u001b[39m],val_acc)]\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m train_acc \u001b[39m=\u001b[39m [his[idx] \u001b[39mfor\u001b[39;00m his,idx \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(history[\u001b[39m'\u001b[39m\u001b[39mtrain_acc\u001b[39m\u001b[39m'\u001b[39m],max_idx)]\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m test_acc \u001b[39m=\u001b[39m [acc[\u001b[39m0\u001b[39m] \u001b[39mfor\u001b[39;00m acc \u001b[39min\u001b[39;00m history[\u001b[39m'\u001b[39m\u001b[39mtest_acc\u001b[39m\u001b[39m'\u001b[39m]]\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=9'>10</a>\u001b[0m df \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mDataFrame(\u001b[39mdict\u001b[39m(val_acc\u001b[39m=\u001b[39mval_acc, train_acc\u001b[39m=\u001b[39mtrain_acc, test_acc\u001b[39m=\u001b[39mtest_acc))\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=11'>12</a>\u001b[0m \u001b[39m# Set plot size\u001b[39;00m\n",
      "\u001b[1;32m/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb Cell 48\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=6'>7</a>\u001b[0m max_idx \u001b[39m=\u001b[39m [his\u001b[39m.\u001b[39mindex(acc) \u001b[39mfor\u001b[39;00m his, acc \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(history[\u001b[39m'\u001b[39m\u001b[39mval_acc\u001b[39m\u001b[39m'\u001b[39m],val_acc)]\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m train_acc \u001b[39m=\u001b[39m [his[idx] \u001b[39mfor\u001b[39;00m his,idx \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(history[\u001b[39m'\u001b[39m\u001b[39mtrain_acc\u001b[39m\u001b[39m'\u001b[39m],max_idx)]\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m test_acc \u001b[39m=\u001b[39m [acc[\u001b[39m0\u001b[39;49m] \u001b[39mfor\u001b[39;00m acc \u001b[39min\u001b[39;00m history[\u001b[39m'\u001b[39m\u001b[39mtest_acc\u001b[39m\u001b[39m'\u001b[39m]]\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=9'>10</a>\u001b[0m df \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mDataFrame(\u001b[39mdict\u001b[39m(val_acc\u001b[39m=\u001b[39mval_acc, train_acc\u001b[39m=\u001b[39mtrain_acc, test_acc\u001b[39m=\u001b[39mtest_acc))\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Bcm013.hpc.nyu.edu/home/as14229/NYU_HPC/semi-supervised-learning/visualize_v3.1.ipynb#X65sdnNjb2RlLXJlbW90ZQ%3D%3D?line=11'>12</a>\u001b[0m \u001b[39m# Set plot size\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'float' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "index = 1\n",
    "# Load Probs from history\n",
    "history = history_list[index]\n",
    "\n",
    "# Make a dataframe to plot\n",
    "val_acc = [max(accs) for accs in history['val_acc']]\n",
    "max_idx = [his.index(acc) for his, acc in zip(history['val_acc'],val_acc)]\n",
    "train_acc = [his[idx] for his,idx in zip(history['train_acc'],max_idx)]\n",
    "test_acc = [acc[0] for acc in history['test_acc']]\n",
    "df = pd.DataFrame(dict(val_acc=val_acc, train_acc=train_acc, test_acc=test_acc))\n",
    "\n",
    "# Set plot size\n",
    "plt.figure(figsize=(10,5))\n",
    "sns.set_style('whitegrid')\n",
    "# Plot the lines\n",
    "sns.lineplot(df,dashes=False,markers='o',palette=sns.color_palette(\"husl\", 3))\n",
    "# Adjust border\n",
    "sns.despine(top=True,right=True)\n",
    "# Set Labels, legends and ticks\n",
    "plt.title('Accuracy Plot')\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend(facecolor=\"w\")\n",
    "# plt.xticks([*range(0,len(history['iteration']),len(history['iteration'])//20)],labels=[*range(1,len(history['iteration'])+1,len(history['iteration'])//20)])\n",
    "# Plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Yahoo_Answers, Run1: 100%|██████████| 20/20 [00:06<00:00,  3.30it/s]\n",
      "Yahoo_Answers, Run2: 100%|██████████| 20/20 [00:06<00:00,  3.14it/s]\n",
      "Yahoo_Answers, Run3: 100%|██████████| 19/19 [00:05<00:00,  3.33it/s]\n",
      "Yahoo_Answers, Run4: 100%|██████████| 19/19 [00:05<00:00,  3.36it/s]\n",
      "Yahoo_Answers, Run5: 100%|██████████| 20/20 [00:06<00:00,  3.13it/s]\n"
     ]
    }
   ],
   "source": [
    "datasets = history_dict.datasets\n",
    "runs = history_dict.runs[0]\n",
    "for dataset in datasets:\n",
    "    for run in runs:\n",
    "        history_list = history_dict[dataset][run]\n",
    "        for history in tqdm(history_list, desc=dataset.title()+', '+run.title()):\n",
    "        \n",
    "            # Make save dir\n",
    "            plots_dir=make_save_dir(history)\n",
    "            \n",
    "            val_acc = [max(accs) for accs in history['val_acc']]\n",
    "            max_idx = [his.index(acc) for his, acc in zip(history['val_acc'],val_acc)]\n",
    "            train_acc = [his[idx] for his,idx in zip(history['train_acc'],max_idx)]\n",
    "            try: test_acc = [acc[0] for acc in history['test_acc']]\n",
    "            except: test_acc = [acc for acc in history['test_acc']]\n",
    "            df = pd.DataFrame(dict(val_acc=val_acc, train_acc=train_acc, test_acc=test_acc))\n",
    "\n",
    "            # Set plot size\n",
    "            plt.figure(figsize=(10,5))\n",
    "            sns.set_style('whitegrid')\n",
    "            # Plot the lines\n",
    "            sns.lineplot(df,dashes=False,markers='o',palette=sns.color_palette(\"husl\", 3))\n",
    "            # Adjust border\n",
    "            sns.despine(top=True,right=True)\n",
    "            # Set Labels, legends and ticks\n",
    "            plt.title('Accuracy Plot')\n",
    "            plt.xlabel(\"Iteration\")\n",
    "            plt.ylabel(\"Accuracy\")\n",
    "            plt.legend(facecolor=\"w\")\n",
    "            # plt.xticks([*range(0,len(history['iteration']),max(len(history['iteration'])//20,1))],\\\n",
    "            #     labels=[*range(1,len(history['iteration'])+1,max(len(history['iteration'])//20,1))])\n",
    "\n",
    "            # Save\n",
    "            plt.savefig(plots_dir+'/'+\"acc_plot.png\",bbox_inches=\"tight\");\n",
    "            plt.clf();\n",
    "            plt.close('all');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### Classwise metrics for each Config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset  : yahoo_answers\n",
      "Strategy : pc_top_k\n",
      "Run      : Run1\n",
      "Indices  : [3, 6, 2, 0]\n",
      "Unique   : [17, 18, 19, 20]\n",
      "Iter Lens: [20, 20, 19, 17, 20, 17, 18, 17, 19, 20, 17, 18, 18, 20, 18, 19, 20, 18, 18, 17]\n"
     ]
    }
   ],
   "source": [
    "dataset = history_dict.datasets[0]\n",
    "run = history_dict.runs[0][0]\n",
    "history_list = history_dict[dataset][run]\n",
    "\n",
    "iter_lens = [len(history['iteration']) for history in history_list]\n",
    "sorted_ = sorted(list(set(iter_lens)))\n",
    "indices = [iter_lens.index(val) for val in sorted_]\n",
    "print('Dataset  :', dataset)\n",
    "print('Strategy :', history_list[0]['strategy'])\n",
    "print('Run      :', run)\n",
    "print('Indices  :', indices)\n",
    "print('Unique   :', sorted_)\n",
    "print('Iter Lens:', iter_lens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 0\n",
    "metric = 'f1' # acc, f1\n",
    "\n",
    "# Load Probs from history\n",
    "history = history_list[index]\n",
    "cw_acc_dict = {class_:[] for class_ in range(len(history['test_cw_'+metric][0][0]))}\n",
    "for cw_acc_list in history['test_cw_'+metric]:\n",
    "    for class_, acc in enumerate(cw_acc_list[0]):\n",
    "        cw_acc_dict[class_].append(acc)\n",
    "\n",
    "df=pd.DataFrame()\n",
    "for key, val in cw_acc_dict.items():\n",
    "    df[class_labels[dataset][key]]=val\n",
    "\n",
    "# Set plot size\n",
    "plt.figure(figsize=(10,5))\n",
    "sns.set_style(\"whitegrid\")\n",
    "# Plot the lines\n",
    "sns.lineplot(df,dashes=False,lw=1.5, markers='o', palette=sns.color_palette(\"husl\", df.shape[1]))\n",
    "# Adjust border\n",
    "sns.despine(top=True,right=True)\n",
    "# Set Labels, legends and ticks\n",
    "plt.title(\"Classwise \"+metric.title()+' Plot')\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(metric.title())\n",
    "plt.legend(facecolor=\"w\",edgecolor='b')\n",
    "# plt.xticks([*range(len(history['iteration']))],labels=[*range(1,len(history['iteration'])+1)])\n",
    "\n",
    "# Plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Yahoo_Answers, Run1: 100%|██████████| 20/20 [00:18<00:00,  1.10it/s]\n",
      "Yahoo_Answers, Run2: 100%|██████████| 20/20 [00:17<00:00,  1.11it/s]\n",
      "Yahoo_Answers, Run3: 100%|██████████| 19/19 [00:17<00:00,  1.11it/s]\n",
      "Yahoo_Answers, Run4: 100%|██████████| 19/19 [00:17<00:00,  1.10it/s]\n",
      "Yahoo_Answers, Run5: 100%|██████████| 20/20 [00:17<00:00,  1.12it/s]\n"
     ]
    }
   ],
   "source": [
    "metrics = ['acc', 'f1'] # acc, f1\n",
    "\n",
    "datasets = history_dict.datasets\n",
    "runs = history_dict.runs[0]\n",
    "for dataset in datasets:\n",
    "    for run in runs:\n",
    "        history_list = history_dict[dataset][run]\n",
    "        for history in tqdm(history_list, desc=dataset.title()+', '+run.title()):\n",
    "            for metric in metrics:\n",
    "                # Make save dir\n",
    "                plots_dir = make_save_dir(history)\n",
    "                \n",
    "                # Load Probs from history\n",
    "                try: cw_acc_dict = {class_:[] for class_ in range(len(history['test_cw_'+metric][0][0]))}\n",
    "                except: cw_acc_dict = {class_:[] for class_ in range(len(history['test_cw_'+metric][0]))}\n",
    "                for cw_acc_list in history['test_cw_'+metric]:\n",
    "                    try:\n",
    "                        for class_, acc in enumerate(cw_acc_list[0]):\n",
    "                            cw_acc_dict[class_].append(acc)\n",
    "                    except:\n",
    "                        for class_, acc in enumerate(cw_acc_list):\n",
    "                            cw_acc_dict[class_].append(acc)\n",
    "\n",
    "                df=pd.DataFrame()\n",
    "                for key, val in cw_acc_dict.items():\n",
    "                    df[class_labels[dataset][key]]=val\n",
    "\n",
    "                # Set plot size\n",
    "                plt.figure(figsize=(10,5))\n",
    "                sns.set_style(\"whitegrid\")\n",
    "                # Plot the lines\n",
    "                sns.lineplot(df,dashes=False,lw=1.5, markers='o', palette=sns.color_palette(\"husl\", df.shape[1]))\n",
    "                # Adjust border\n",
    "                sns.despine(top=True,right=True)\n",
    "                # Set Labels, legends and ticks\n",
    "                plt.title(\"Classwise \"+metric.title()+' Plot')\n",
    "                plt.xlabel(\"Iteration\")\n",
    "                plt.ylabel(metric.title())\n",
    "                plt.legend(facecolor=\"w\")\n",
    "                # plt.xticks([*range(len(history['iteration']))],labels=[*range(1,len(history['iteration'])+1)])\n",
    "\n",
    "                # Save\n",
    "                plt.savefig(plots_dir+'/'+\"cw_\"+metric+\"_plot.png\",bbox_inches=\"tight\");\n",
    "                plt.clf();\n",
    "                plt.close('all');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### 3.4 Selection plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset  : yahoo_answers\n",
      "Strategy : pc_top_k\n",
      "Run      : Run4\n",
      "Indices  : [0]\n",
      "Unique   : [20]\n",
      "Iter Lens: [20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "dataset = history_dict.datasets[0]\n",
    "run = history_dict.runs[0][3]\n",
    "history_list = history_dict[dataset][run]\n",
    "\n",
    "iter_lens = [len(history['iteration']) for history in history_list]\n",
    "sorted_ = sorted(list(set(iter_lens)))\n",
    "indices = [iter_lens.index(val) for val in sorted_]\n",
    "print('Dataset  :', dataset)\n",
    "print('Strategy :', history_list[0]['strategy'])\n",
    "print('Run      :', run)\n",
    "print('Indices  :', indices)\n",
    "print('Unique   :', sorted_)\n",
    "print('Iter Lens:', iter_lens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 0\n",
    "\n",
    "# Load Probs from history\n",
    "history = history_list[index]\n",
    "\n",
    "# Make a dataframe to plot\n",
    "in_domain = deepcopy(history['selected_in_domain'])\n",
    "out_domain = deepcopy([a-b for a,b in zip(history['selected_set_size'],history['selected_in_domain'])])\n",
    "selected = deepcopy(history['selected_set_size'])\n",
    "\n",
    "for i in range(1,len(in_domain)):\n",
    "    in_domain[i] = in_domain[i-1]+in_domain[i]\n",
    "    out_domain[i] = out_domain[i-1]+out_domain[i]\n",
    "    selected [i]= selected[i-1]+selected[i]\n",
    "\n",
    "df = pd.DataFrame(dict(in_domain=in_domain, out_domain=out_domain, selected=selected))\n",
    "\n",
    "# Set plot size\n",
    "plt.figure(figsize=(6,3))\n",
    "sns.set_style(\"whitegrid\")\n",
    "# Plot the lines\n",
    "sns.lineplot(df,dashes=False,markers='o',palette=sns.color_palette(\"husl\", 3))\n",
    "# Adjust border\n",
    "sns.despine(top=True,right=True)\n",
    "# Set Labels, legends and ticks\n",
    "plt.title('Cumulative Selection Plot')\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Count\")\n",
    "plt.legend(facecolor=\"w\",edgecolor='b')\n",
    "# plt.xticks([*range(len(history['iteration']))],labels=[*range(1,len(history['iteration'])+1)])\n",
    "\n",
    "# Plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Yahoo_Answers, Run1: 100%|██████████| 20/20 [00:06<00:00,  3.29it/s]\n",
      "Yahoo_Answers, Run2: 100%|██████████| 20/20 [00:06<00:00,  3.04it/s]\n",
      "Yahoo_Answers, Run3: 100%|██████████| 19/19 [00:06<00:00,  3.10it/s]\n",
      "Yahoo_Answers, Run4: 100%|██████████| 19/19 [00:06<00:00,  3.16it/s]\n",
      "Yahoo_Answers, Run5: 100%|██████████| 20/20 [00:06<00:00,  2.98it/s]\n"
     ]
    }
   ],
   "source": [
    "datasets = history_dict.datasets\n",
    "runs = history_dict.runs[0]\n",
    "for dataset in datasets:\n",
    "    for run in runs:\n",
    "        history_list = history_dict[dataset][run]\n",
    "        for history in tqdm(history_list, desc=dataset.title()+', '+run.title()):\n",
    "        \n",
    "            # Make save dir\n",
    "            plots_dir=make_save_dir(history)\n",
    "\n",
    "            # Make a dataframe to plot\n",
    "            in_domain = deepcopy(history['selected_in_domain'])\n",
    "            out_domain = deepcopy([a-b for a,b in zip(history['selected_set_size'],history['selected_in_domain'])])\n",
    "            selected = deepcopy(history['selected_set_size'])\n",
    "\n",
    "            for i in range(1,len(in_domain)):\n",
    "                in_domain[i] = in_domain[i-1]+in_domain[i]\n",
    "                out_domain[i] = out_domain[i-1]+out_domain[i]\n",
    "                selected [i]= selected[i-1]+selected[i]\n",
    "\n",
    "            df = pd.DataFrame(dict(in_domain=in_domain, out_domain=out_domain, selected=selected))\n",
    "\n",
    "            # Set plot size\n",
    "            plt.figure(figsize=(10,5))\n",
    "            sns.set_style(\"whitegrid\")\n",
    "            # Plot the lines\n",
    "            sns.lineplot(df,dashes=False,markers='o',palette=sns.color_palette(\"husl\", 3))\n",
    "            # Adjust border\n",
    "            sns.despine(top=True,right=True)\n",
    "            # Set Labels, legends and ticks\n",
    "            plt.title('Cumulative Selection Plot')\n",
    "            plt.xlabel(\"Iteration\")\n",
    "            plt.ylabel(\"Count\")\n",
    "            plt.legend(facecolor=\"w\")\n",
    "            # plt.xticks([*range(len(history['iteration']))],labels=[*range(1,len(history['iteration'])+1)])\n",
    "\n",
    "            # Save\n",
    "            plt.savefig(plots_dir+'/'+\"selection_plot.png\",bbox_inches=\"tight\");\n",
    "            plt.clf();\n",
    "            plt.close('all');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### 3.5 Distribution Counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distribution = 'train'\n",
    "index = 5\n",
    "for history in history_list[index:index+1]:\n",
    "    pre_title = 'Threshold: '+str(history['threshold']) if history['strategy']=='threshold' else\\\n",
    "                'Top K: '+str(history['top_k']) , \"Labeled Size:\"+str(history['labeled_set_size'][0])+\\\n",
    "                    \", Unlabeled Classes: \"+str(len(history['unlabeled_classes']))\n",
    "    print(distribution.title()+' Distribution,',pre_title)\n",
    "    \n",
    "    itr = history['iteration']\n",
    "    unlabeled_dist = [val.values() for val in history[distribution.lower()+'_distribution']]\n",
    "   \n",
    "    df = pd.DataFrame(columns=['Iteration']+[str(clss) for clss in history[distribution.lower()+'_distribution'][0].keys()])\n",
    "    for i, counts in zip(itr,unlabeled_dist):\n",
    "        df.loc[len(df)] = [i]+ list(counts)\n",
    "\n",
    "    display(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Debug"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.colors.qualitative.swatches()\n",
    "fig.update_layout(template='plotly_white')\n",
    "fig.write_html(base_dir+\"/colors.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['aggrnyl', 'agsunset', 'blackbody', 'bluered', 'blues', 'blugrn', 'bluyl', 'brwnyl', 'bugn', 'bupu', 'burg', 'burgyl', 'cividis', 'darkmint', 'electric', 'emrld', 'gnbu', 'greens', 'greys', 'hot', 'inferno', 'jet', 'magenta', 'magma', 'mint', 'orrd', 'oranges', 'oryel', 'peach', 'pinkyl', 'plasma', 'plotly3', 'pubu', 'pubugn', 'purd', 'purp', 'purples', 'purpor', 'rainbow', 'rdbu', 'rdpu', 'redor', 'reds', 'sunset', 'sunsetdark', 'teal', 'tealgrn', 'turbo', 'viridis', 'ylgn', 'ylgnbu', 'ylorbr', 'ylorrd', 'algae', 'amp', 'deep', 'dense', 'gray', 'haline', 'ice', 'matter', 'solar', 'speed', 'tempo', 'thermal', 'turbid', 'armyrose', 'brbg', 'earth', 'fall', 'geyser', 'prgn', 'piyg', 'picnic', 'portland', 'puor', 'rdgy', 'rdylbu', 'rdylgn', 'spectral', 'tealrose', 'temps', 'tropic', 'balance', 'curl', 'delta', 'oxy', 'edge', 'hsv', 'icefire', 'phase', 'twilight', 'mrybm', 'mygbm']\n"
     ]
    }
   ],
   "source": [
    "print(px.colors.named_colorscales())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for name in history_files:\n",
    "    history = torch.load(name)\n",
    "    labeled = history['labeled_set_size'][1:]+[history['unlabeled_set_size'][0]]\n",
    "    unlabeled = history['unlabeled_set_size'][1:]+[0]\n",
    "    history['labeled_set_size']=labeled\n",
    "    history['unlabeled_set_size']=unlabeled\n",
    "    torch.save(history,name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for root, dirs, files in os.walk(\"./history\"):\n",
    "   for name in files:\n",
    "      print(os.path.join(root, name))\n",
    "   for name in dirs:\n",
    "      print(os.path.join(root, name))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "history_dict = dict()\n",
    "\n",
    "for dataset in os.listdir(history_dir):\n",
    "    dataset_path = os.path.join(history_dir,dataset)\n",
    "    if os.path.isdir(dataset_path):\n",
    "        for run in os.listdir(dataset_path):\n",
    "            run_path = os.path.join(dataset_path,run)\n",
    "            if os.path.isdir(run_path):\n",
    "                \n",
    "                if dataset in history_dict: history_dict[dataset][run] = []\n",
    "                else: history_dict[dataset] = {run:[]}\n",
    "                \n",
    "                for path, dirs, files in os.walk(run_path):\n",
    "                    for file_ in files:\n",
    "                        if file_[-10:] == 'history.pt':\n",
    "                            splits=file_.split('_')\n",
    "                            name = '_'.join(splits[1:-1]+['e'+splits[0]]+[splits[-1]])\n",
    "                            try:\n",
    "                                os.rename(os.path.join(run_path,file_), os.path.join(run_path,name))\n",
    "                            except:\n",
    "                                pass\n",
    "                            \n",
    "                            # history_dict[dataset][run].append(file_)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100_equal_100_15000_25_e20_history.pt\n",
      "100_equal_5000_15000_75_e17_history.pt\n"
     ]
    }
   ],
   "source": [
    "files = ['20_100_equal_100_15000_25_history.pt', '17_100_equal_5000_15000_75_history.pt']\n",
    "\n",
    "for file_ in files:\n",
    "    splits=file_.split('_')\n",
    "    print('_'.join(splits[1:-1]+['e'+splits[0]]+[splits[-1]]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100_equal_100_15000_25_e20_history.pt\n"
     ]
    }
   ],
   "source": [
    "splits='20_100_equal_100_15000_25_history.pt'.split('_')\n",
    "print('_'.join(splits[1:-1]+['e'+splits[0]]+[splits[-1]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for path, dirs, files in os.walk(history_dir):\n",
    "    print(files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['setup.py',\n",
       " 'history',\n",
       " '.old',\n",
       " 'docs',\n",
       " 'LICENSE',\n",
       " '.vscode',\n",
       " 'visualize_v3.0.ipynb',\n",
       " 'utils',\n",
       " 'temp',\n",
       " 'prev_versions',\n",
       " 'self_train_v3.0.py',\n",
       " 'self_train_v3.0 copy.py',\n",
       " 'README.md',\n",
       " '.gitignore',\n",
       " 'changelog.md',\n",
       " 'data',\n",
       " '__pycache__',\n",
       " '.git',\n",
       " 'scripts',\n",
       " '.cache']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['yahoo_answers']\n"
     ]
    }
   ],
   "source": [
    "print(os.listdir(history_dir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "2d16b7065a7b6c736c1e1086f6450fd457f50d264e4008e1f14cb5793d37f9a9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}