notebooks/Visualize classification model label embeddings.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better speed can be achieved with apex installed from https://www.github.com/nvidia/apex.\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "from allennlp.nn.util import move_to_device\n",
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "import pandas as pd\n",
    "from umap import UMAP\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import json\n",
    "\n",
    "from SocialMediaIE.data.tokenization import get_match_iter, get_match_object\n",
    "\n",
    "from SocialMediaIE.predictor.model_predictor_classification import run, get_args, PREFIX, get_model_output, output_to_json\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_context(\"talk\")\n",
    "sns.set_style(\"ticks\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\ProgramData\\Miniconda3\\envs\\SocialMediaIE\\lib\\site-packages\\torch\\nn\\modules\\rnn.py:46: UserWarning: dropout option adds dropout after all but last recurrent layer, so non-zero dropout expects num_layers greater than 1, but got dropout=0.5 and num_layers=1\n",
      "  \"num_layers={}\".format(dropout, num_layers))\n"
     ]
    }
   ],
   "source": [
    "MODEL_NAME=\"all_multitask_shared_bilstm_l2_0_lr_1e-3\"\n",
    "SERIALIZATION_DIR = os.path.realpath(f\"../data/models_classification/{MODEL_NAME}/\")\n",
    "args = get_args(PREFIX, SERIALIZATION_DIR)\n",
    "TASKS, vocab, model, readers, test_iterator = run(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model's state_dict:\n",
      "word_embeddings.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "word_embeddings.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "encoders.abusive._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "encoders.abusive._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "encoders.abusive._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "encoders.abusive._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "encoders.abusive._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "encoders.abusive._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "encoders.abusive._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "encoders.abusive._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "encoders.sentiment._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "encoders.sentiment._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "encoders.sentiment._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "encoders.sentiment._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "encoders.sentiment._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "encoders.sentiment._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "encoders.sentiment._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "encoders.sentiment._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "encoders.uncertainity._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "encoders.uncertainity._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "encoders.uncertainity._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "encoders.uncertainity._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "encoders.uncertainity._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "encoders.uncertainity._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "encoders.uncertainity._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "encoders.uncertainity._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.founta_abusive._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.founta_abusive._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.founta_abusive._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.founta_abusive._classification_layer.weight \t torch.Size([4, 200])\n",
      "classifier.founta_abusive._classification_layer.bias \t torch.Size([4])\n",
      "classifier.waseem_abusive._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.waseem_abusive._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.waseem_abusive._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.waseem_abusive._classification_layer.weight \t torch.Size([3, 200])\n",
      "classifier.waseem_abusive._classification_layer.bias \t torch.Size([3])\n",
      "classifier.sarcasm_uncertainity._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.sarcasm_uncertainity._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.sarcasm_uncertainity._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.sarcasm_uncertainity._classification_layer.weight \t torch.Size([2, 200])\n",
      "classifier.sarcasm_uncertainity._classification_layer.bias \t torch.Size([2])\n",
      "classifier.veridicality_uncertainity._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.veridicality_uncertainity._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.veridicality_uncertainity._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.veridicality_uncertainity._classification_layer.weight \t torch.Size([5, 200])\n",
      "classifier.veridicality_uncertainity._classification_layer.bias \t torch.Size([5])\n",
      "classifier.semeval_sentiment._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.semeval_sentiment._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.semeval_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.semeval_sentiment._classification_layer.weight \t torch.Size([3, 200])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "classifier.semeval_sentiment._classification_layer.bias \t torch.Size([3])\n",
      "classifier.clarin_sentiment._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.clarin_sentiment._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.clarin_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.clarin_sentiment._classification_layer.weight \t torch.Size([3, 200])\n",
      "classifier.clarin_sentiment._classification_layer.bias \t torch.Size([3])\n",
      "classifier.politics_sentiment._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.politics_sentiment._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.politics_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.politics_sentiment._classification_layer.weight \t torch.Size([3, 200])\n",
      "classifier.politics_sentiment._classification_layer.bias \t torch.Size([3])\n",
      "classifier.other_sentiment._text_field_embedder.token_embedder_tokens._projection.weight \t torch.Size([100, 1024])\n",
      "classifier.other_sentiment._text_field_embedder.token_embedder_tokens._projection.bias \t torch.Size([100])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0 \t torch.Size([400, 100])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0 \t torch.Size([400, 100])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0 \t torch.Size([400])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0 \t torch.Size([400])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.weight_ih_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.weight_hh_l0_reverse \t torch.Size([400, 100])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.bias_ih_l0_reverse \t torch.Size([400])\n",
      "classifier.other_sentiment._seq2vec_encoder._module.moduleList.0.bias_hh_l0_reverse \t torch.Size([400])\n",
      "classifier.other_sentiment._classification_layer.weight \t torch.Size([3, 200])\n",
      "classifier.other_sentiment._classification_layer.bias \t torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "print(\"Model's state_dict:\")\n",
    "for param_tensor in model.state_dict():\n",
    "    if \"elmo\" not in param_tensor:\n",
    "        print(param_tensor, \"\\t\", model.state_dict()[param_tensor].size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 1, 1,  ..., 1, 1, 1],\n",
       "        [1, 1, 1,  ..., 1, 1, 1],\n",
       "        [1, 1, 1,  ..., 1, 1, 1],\n",
       "        ...,\n",
       "        [1, 1, 1,  ..., 1, 1, 1],\n",
       "        [1, 1, 1,  ..., 1, 1, 1],\n",
       "        [1, 1, 1,  ..., 1, 1, 1]], device='cuda:0', dtype=torch.uint8)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k1 = \"encoders.abusive._module.moduleList.0.weight_ih_l0\"\n",
    "k2 = \"encoders.sentiment._module.moduleList.0.weight_ih_l0\"\n",
    "model.state_dict()[k1] == model.state_dict()[k2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model's state_dict:\n",
      "founta_abusive\t['normal', 'spam', 'abusive', 'hateful']\ttorch.Size([4, 200])\n",
      "waseem_abusive\t['none', 'sexism', 'racism']\ttorch.Size([3, 200])\n",
      "sarcasm_uncertainity\t['not_sarcasm', 'sarcasm']\ttorch.Size([2, 200])\n",
      "veridicality_uncertainity\t['uncertain', 'definitely_yes', 'probably_yes', 'probably_no', 'definitely_no']\ttorch.Size([5, 200])\n",
      "semeval_sentiment\t['positive', 'neutral', 'negative']\ttorch.Size([3, 200])\n",
      "clarin_sentiment\t['neutral', 'positive', 'negative']\ttorch.Size([3, 200])\n",
      "politics_sentiment\t['negative', 'neutral', 'positive']\ttorch.Size([3, 200])\n",
      "other_sentiment\t['negative', 'neutral', 'positive']\ttorch.Size([3, 200])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "((26, 200),\n",
       " ['founta_abusive.normal',\n",
       "  'founta_abusive.spam',\n",
       "  'founta_abusive.abusive',\n",
       "  'founta_abusive.hateful',\n",
       "  'waseem_abusive.none',\n",
       "  'waseem_abusive.sexism',\n",
       "  'waseem_abusive.racism',\n",
       "  'sarcasm_uncertainity.not_sarcasm',\n",
       "  'sarcasm_uncertainity.sarcasm',\n",
       "  'veridicality_uncertainity.uncertain',\n",
       "  'veridicality_uncertainity.definitely_yes',\n",
       "  'veridicality_uncertainity.probably_yes',\n",
       "  'veridicality_uncertainity.probably_no',\n",
       "  'veridicality_uncertainity.definitely_no',\n",
       "  'semeval_sentiment.positive',\n",
       "  'semeval_sentiment.neutral',\n",
       "  'semeval_sentiment.negative',\n",
       "  'clarin_sentiment.neutral',\n",
       "  'clarin_sentiment.positive',\n",
       "  'clarin_sentiment.negative',\n",
       "  'politics_sentiment.negative',\n",
       "  'politics_sentiment.neutral',\n",
       "  'politics_sentiment.positive',\n",
       "  'other_sentiment.negative',\n",
       "  'other_sentiment.neutral',\n",
       "  'other_sentiment.positive'])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Model's state_dict:\")\n",
    "\n",
    "all_weights = []\n",
    "all_keys = []\n",
    "all_tasks = []\n",
    "\n",
    "for param_tensor in model.state_dict():\n",
    "    if param_tensor.endswith(\"._classification_layer.weight\"):\n",
    "        task_name = param_tensor.split(\".\")[1]\n",
    "        all_tasks.append(task_name)\n",
    "        vocab_items = [vocab.get_token_from_index(i, task_name) for i in range(vocab.get_vocab_size(task_name))]\n",
    "        task_classifier_weights = model.state_dict()[param_tensor]\n",
    "        all_weights.append(task_classifier_weights.cpu().numpy())\n",
    "        all_keys.extend([f\"{task_name}.{v}\" for v in vocab_items])\n",
    "        print(f\"{task_name}\\t{vocab_items}\\t{task_classifier_weights.size()}\")\n",
    "all_weights = np.vstack(all_weights)\n",
    "all_weights.shape, all_keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_embedded = UMAP(n_components=2).fit_transform(all_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 10))\n",
    "\n",
    "for i, (key, (x, y)) in enumerate(zip(all_keys, X_embedded)):\n",
    "    plt.scatter(x, y, marker='x', color='red')\n",
    "    plt.text(x+.03, y+.03, key, fontsize=9)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0.4, 0.7607843137254902, 0.6470588235294118),\n",
       " (0.9882352941176471, 0.5529411764705883, 0.3843137254901961),\n",
       " (0.5529411764705883, 0.6274509803921569, 0.796078431372549),\n",
       " (0.9058823529411765, 0.5411764705882353, 0.7647058823529411),\n",
       " (0.6509803921568628, 0.8470588235294118, 0.32941176470588235),\n",
       " (1.0, 0.8509803921568627, 0.1843137254901961),\n",
       " (0.8980392156862745, 0.7686274509803922, 0.5803921568627451),\n",
       " (0.7019607843137254, 0.7019607843137254, 0.7019607843137254)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sns.color_palette(\"Set2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>task_labels</th>\n",
       "      <th>d1</th>\n",
       "      <th>d2</th>\n",
       "      <th>task</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>founta_abusive.normal</td>\n",
       "      <td>2.063343</td>\n",
       "      <td>-1.007219</td>\n",
       "      <td>founta_abusive</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>founta_abusive.spam</td>\n",
       "      <td>2.119366</td>\n",
       "      <td>-2.892117</td>\n",
       "      <td>founta_abusive</td>\n",
       "      <td>spam</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>founta_abusive.abusive</td>\n",
       "      <td>4.516266</td>\n",
       "      <td>-3.152872</td>\n",
       "      <td>founta_abusive</td>\n",
       "      <td>abusive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>founta_abusive.hateful</td>\n",
       "      <td>3.886361</td>\n",
       "      <td>-3.466821</td>\n",
       "      <td>founta_abusive</td>\n",
       "      <td>hateful</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>waseem_abusive.none</td>\n",
       "      <td>1.797528</td>\n",
       "      <td>-1.338207</td>\n",
       "      <td>waseem_abusive</td>\n",
       "      <td>none</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              task_labels        d1        d2            task    label\n",
       "0   founta_abusive.normal  2.063343 -1.007219  founta_abusive   normal\n",
       "1     founta_abusive.spam  2.119366 -2.892117  founta_abusive     spam\n",
       "2  founta_abusive.abusive  4.516266 -3.152872  founta_abusive  abusive\n",
       "3  founta_abusive.hateful  3.886361 -3.466821  founta_abusive  hateful\n",
       "4     waseem_abusive.none  1.797528 -1.338207  waseem_abusive     none"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({\"task_labels\": all_keys, \"d1\": X_embedded[:, 0], \"d2\": X_embedded[:, 1]})\n",
    "df = pd.concat([df, df.task_labels.str.split(\".\", expand=True).rename(columns={0: \"task\", 1: \"label\"})], axis=1)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 10))\n",
    "\n",
    "ax = sns.scatterplot(x=\"d1\", y=\"d2\", data=df, style=\"task\", hue=\"task\", s=200)\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "for i, row in df.iterrows():\n",
    "    #ax.text(row.d1+.1, row.d2+.1, row.label, fontsize=16)\n",
    "    ax.annotate(\n",
    "        row.label, \n",
    "        xy=(row.d1, row.d2), xytext=(0, 0), \n",
    "        textcoords='offset points',\n",
    "        fontsize=14\n",
    "    )\n",
    "    \n",
    "sns.despine(offset=10)\n",
    "plt.savefig(f\"../figures/multitask_learning/classification_{MODEL_NAME}_labels.pdf\", bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}