artemis/notebooks/analysis/concreteness_subjectivity_sentiment_and_POS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyze some fancier properties of ArtEmis and compare it (optionally) with other common datasets.\n",
    "    - Concreteness, \n",
    "    - Subjectivity based on TextBlob \n",
    "    - Sentimenet-Analysis based on (nltk) Vader\n",
    "    - The above metrics on ArtEmis per art-gerne \n",
    "    - Parts-Of-Speech\n",
    "\n",
    "* Note. Please contact optas@stanford for the files corresponding to the other datasets if you do not have access to them. I will streamline this in April. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import nltk\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import matplotlib.pylab as plt\n",
    "from collections import Counter\n",
    "from functools import partial\n",
    "from ast import literal_eval\n",
    "from nltk.sentiment.vader import SentimentIntensityAnalyzer\n",
    "\n",
    "from artemis.utils.basic import df_parallel_column_apply\n",
    "from artemis.analysis.utils import contains_word, contains_bigrams, concreteness_of_sentence, pos_analysis\n",
    "from artemis.language.basics import tokenize_and_spell, ngrams\n",
    "from artemis.language.part_of_speech import nltk_parallel_tagging_of_tokens\n",
    "from artemis.utils.visualization import plot_overlayed_two_histograms\n",
    "from artemis.utils.other_datasets.flickr30K_entities import load_all_linguistic_annotations\n",
    "from artemis.utils.other_datasets.conceptual_captions import load_conceptual_captions\n",
    "from artemis.utils.other_datasets.google_refexp import load_google_refexp_captions\n",
    "\n",
    "sns.set()\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from textblob import TextBlob    \n",
    "except:\n",
    "    print('For analyzing the subjectivity (bottom parts of notebook) you need to install textblob')  \n",
    "    print('e.g., conda install -c conda-forge textblob')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "freq_file = '../../data/symspell_frequency_dictionary_en_82_765.txt'\n",
    "glove_file = '../../data/glove.6B.100d.vocabulary.txt'\n",
    "\n",
    "## Use your path:\n",
    "artemis_preprocessed_csv = '/home/optas/DATA/OUT/artemis/preprocessed_data/for_analysis/artemis_preprocessed.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## For the following files send to me an email (optas@stanford.edu) \n",
    "## (or git-pull on April 7) P.s. they are available online\n",
    "##\n",
    "brm_file=\\\n",
    "'/home/optas/DATA/Language/sentiment_psychology/abstractness_BRM/Concreteness_ratings_Brysbaert_et_al_BRM.xlsx'\n",
    "\n",
    "coco_file=\\\n",
    "'/home/optas/DATA/OUT/ela/coco_related/coco2014_captions.csv'\n",
    "\n",
    "flickr_dir=\\\n",
    "'/home/optas/DATA/Language/flickr30Kentities/annotations/Sentences/'\n",
    "\n",
    "conceptual_caps_train=\\\n",
    "'/home/optas/DATA/Language/conceptual_captions/Train_GCC-training.tsv'\n",
    "\n",
    "conceptual_caps_val=\\\n",
    "'/home/optas/DATA/Language/conceptual_captions/Validation_GCC-1.1.0-Validation.tsv'\n",
    "\n",
    "google_refexp_train=\\\n",
    "'/home/optas/DATA/Language/google_refexp/google_refexp_train_201511.json'\n",
    "\n",
    "google_refexp_val=\\\n",
    "'/home/optas/DATA/Language/google_refexp/google_refexp_val_201511.json'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Hyper-params for notebook \n",
    "##\n",
    "load_ela = True\n",
    "load_coco = True\n",
    "\n",
    "load_flickr = False  # if turn on, it will also load/contrast with this datatasets.\n",
    "load_concept_caps = False\n",
    "load_google_refexp = False\n",
    "\n",
    "brm_drop_articles = True # use or not the: \"the\", \"a\", \"an\", \"every\".\n",
    "spell_check_non_artemis_data = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SymSpell spell-checker loaded: True\n",
      "Loading glove word embeddings.\n",
      "Done. 400000 words loaded.\n",
      "Updating Glove vocabulary with *valid* ArtEmis words that are missing from it.\n"
     ]
    }
   ],
   "source": [
    "### Load -datasets-\n",
    "datasets = dict()\n",
    "if load_ela:\n",
    "    df = pd.read_csv(artemis_preprocessed_csv)\n",
    "    df.tokens = df.tokens.apply(literal_eval)\n",
    "    datasets['ArtEmis'] = df\n",
    "    \n",
    "\n",
    "if load_coco:        \n",
    "    df = pd.read_csv(coco_file)\n",
    "    coco_missed_tokens = tokenize_and_spell(df, glove_file, freq_file, \n",
    "                                            nltk.word_tokenize, spell_check=spell_check_non_artemis_data)\n",
    "    datasets['COCO'] = df\n",
    "    \n",
    "\n",
    "if load_flickr:\n",
    "    df = load_all_linguistic_annotations(flickr_dir)    \n",
    "    coco_missed_tokens = tokenize_and_spell(df, glove_file, freq_file, \n",
    "                                            nltk.word_tokenize, spell_check=spell_check_non_artemis_data)\n",
    "    datasets['Flickr'] = df\n",
    "    \n",
    "    \n",
    "if load_concept_caps:    \n",
    "    ## Quick and Dirty\n",
    "    df = load_conceptual_captions(conceptual_caps_train, conceptual_caps_val, only_language=True)\n",
    "    cc_missed_tokens = tokenize_and_spell(df, glove_file, freq_file, \n",
    "                                          nltk.word_tokenize, spell_check=spell_check_non_artemis_data)\n",
    "    datasets['ConceptualCaptions'] = df\n",
    "    \n",
    "    \n",
    "if load_google_refexp:\n",
    "    df = load_google_refexp_captions(google_refexp_train, google_refexp_val)\n",
    "    refexp_missed_tokens = tokenize_and_spell(df, glove_file, freq_file, \n",
    "                                              nltk.word_tokenize, spell_check=spell_check_non_artemis_data)\n",
    "    datasets['GoogleRefxp'] = df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ArtEmis N-sentences: 454684 Average Length: 15.9\n",
      "COCO N-sentences: 616767 Average Length: 10.5\n"
     ]
    }
   ],
   "source": [
    "for k, v in datasets.items():\n",
    "    print(k, 'N-sentences:', len(v), 'Average Length:', v.tokens_len.mean().round(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Conreteness Analysis\n",
    "##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Load \"concreteness and abstractness\" values\n",
    "#\n",
    "\n",
    "## Note. If your pandas cannot read excel do:\n",
    "## else:  pip install xlrd==1.2.0\n",
    "\n",
    "brm_data = pd.read_excel(brm_file)\n",
    "brm_data.Word = brm_data.Word.apply(lambda x: str(x).lower())\n",
    "\n",
    "if brm_drop_articles:\n",
    "    brm_data = brm_data[brm_data.Dom_Pos != 'Article']\n",
    "    \n",
    "brm_data = brm_data[['Word', 'Conc.M']]\n",
    "brm_data.columns = ['word', 'concreteness']\n",
    "word_to_concreteness = dict(zip(brm_data.word, brm_data.concreteness))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ArtEmis concreteness 2.81 2.78\n",
      "COCO concreteness 3.55 3.57\n"
     ]
    }
   ],
   "source": [
    "concreteness_scores = dict()\n",
    "for dset_name in datasets:    \n",
    "    concreteness_scores[dset_name] = datasets[dset_name].tokens.apply(lambda x: concreteness_of_sentence(x, word_to_concreteness))    \n",
    "    smean = concreteness_scores[dset_name].mean().round(2)\n",
    "    smedian = concreteness_scores[dset_name].median().round(2)\n",
    "    print(dset_name, 'concreteness', smean, smedian)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x1 = concreteness_scores['ArtEmis'][~concreteness_scores['ArtEmis'].isna()]\n",
    "x2 = concreteness_scores['COCO'][~concreteness_scores['COCO'].isna()]\n",
    "\n",
    "fig = plot_overlayed_two_histograms(x2, x1, min_val=1.4, max_val=5.0, \n",
    "                                    n_bins=20, alpha=0.8, labels=['COCO', 'ArtEmis']);\n",
    "\n",
    "fig.axes[0].set_xlabel('Concreteness Scores')\n",
    "fig.savefig('ArtEmis_vs_COCO_concreteness.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.784166666666667, 3.5657142857142854)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1.median(), x2.median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percentile of most abstract: 1\n",
      "Number of words/bigrams to be used as abstract: 424 4\n",
      "0.31532448909572364\n",
      "0.026355171401842188\n"
     ]
    }
   ],
   "source": [
    "# restrict to the most abstract words, bigrams (per percentile value). How many of those are precent in eaach dataset?\n",
    "wc_vals = list(word_to_concreteness.values())\n",
    "prc = 1\n",
    "conc_threshold = np.percentile(wc_vals, prc)\n",
    "abstract_unigrams = set()\n",
    "abstract_bigrams = set()\n",
    "for k, v in word_to_concreteness.items():\n",
    "    if v <= conc_threshold:\n",
    "        if ' ' in k:\n",
    "            abstract_bigrams.add(k)\n",
    "        else:\n",
    "            abstract_unigrams.add(k)            \n",
    "\n",
    "print('Percentile of most abstract:', prc)\n",
    "print('Number of words/bigrams to be used as abstract:', len(abstract_unigrams), len(abstract_bigrams))\n",
    "\n",
    "uses_abstract = contains_word(datasets['ArtEmis'].tokens, abstract_unigrams)\n",
    "uses_abstract |= datasets['ArtEmis'].tokens.apply(partial(contains_bigrams, abstract_bigrams))\n",
    "print(uses_abstract.mean())\n",
    "\n",
    "uses_abstract = contains_word(datasets['COCO'].tokens, abstract_unigrams)\n",
    "uses_abstract |= datasets['COCO'].tokens.apply(partial(contains_bigrams, abstract_bigrams))\n",
    "print(uses_abstract.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Sentiment Analysis\n",
    "##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vader_classify(score, threshold=0.05):\n",
    "    if abs(score) < threshold:\n",
    "        return 'neutral'\n",
    "\n",
    "    if score > 0:\n",
    "        return 'positive'\n",
    "\n",
    "    if score < 0:\n",
    "        return 'negative'\n",
    "    \n",
    "def vader_score(sentence):\n",
    "    return vader.polarity_scores(sentence)['compound']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentiment_scores = dict()\n",
    "vader = SentimentIntensityAnalyzer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ArtEmis sentiment-score 0.44 0.46\n",
      "COCO sentiment-score 0.07 0.0\n"
     ]
    }
   ],
   "source": [
    "for dset_name in datasets:    \n",
    "    sentiment_scores[dset_name] = datasets[dset_name]['utterance_spelled'].apply(lambda x: vader.polarity_scores(x)['compound'])\n",
    "    scores = sentiment_scores[dset_name]\n",
    "    smean = scores.abs().mean().round(2)\n",
    "    smedian = scores.abs().median().round(2)    \n",
    "    print(dset_name, 'sentiment-score', smean, smedian)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentiment_classes_list = []  # aggregate for all datasets to make a nice plot\n",
    "dataset_names = []\n",
    "sentiment_classes = dict()\n",
    "threshold = 0.05\n",
    "for name in sentiment_scores:\n",
    "    temp = sentiment_scores[name].apply(lambda x: vader_classify(x, threshold=threshold))\n",
    "    sentiment_classes[name] = temp    \n",
    "    sentiment_classes_list.extend(temp.to_list())\n",
    "    dataset_names.extend(len(temp) * [name])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ArtEmis 0.164558242647641\n",
      "COCO 0.7744512919789808\n"
     ]
    }
   ],
   "source": [
    "for name in sentiment_classes:\n",
    "    print(name, (sentiment_classes[name] == 'neutral').mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = pd.DataFrame(dataset_names, columns=['dataset'])\n",
    "d2 = pd.DataFrame(sentiment_classes_list, columns=['sentiment-class'])\n",
    "aggregate_sentiment_stats = pd.concat([d1, d2], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c = sns.catplot(x=\"dataset\", \n",
    "                hue=\"sentiment-class\", \n",
    "                data=aggregate_sentiment_stats, \n",
    "                kind=\"count\",                 \n",
    "                palette={\"negative\": \"#FE2020\", \n",
    "                         \"positive\": \"#2f9c3b\", \n",
    "                         \"neutral\": \"#6b8abd\"},                                \n",
    "                legend_out=False,\n",
    "               )\n",
    "c.savefig('ArtEmis_vs_COCO_sentiment_classes.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAENCAYAAAAhRzNRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAllElEQVR4nO3de1iUZd4H8O/MM4AHQB3iMHjIxNBJMw8kalIrkiihpmUYq+1m5qppppViKWxqrpRvlkYeMt03LzUPJSVimOuWbQc3UzPFFHkxFUZQ0AA1kJn7/YN1VgTmcM9J8Pu5Lq9L5n7ueX5zD/p9jvejEkIIEBER2Unt6QKIiKhhYoAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFJsCJDo6GoMHD8bw4cMxfPhwfP311wCAvLw8JCQkIDY2FgkJCTh16pS5j7vbiIjIzYQNBgwYII4fP17r9bFjx4r09HQhhBDp6eli7NixHmsjIiL3Uglh/UbC6OhorFixAuHh4ebXiouLERsbi3379kFRFBiNRkRGRmLXrl0QQri1TavV2hyYFy9ehslk/72TAQG+KC4ut7ufq7Eu+7Au+7Au+zTGutRqFVq1al5nm8bWN3nppZcghECvXr0wY8YMGAwGBAcHQ1EUAICiKAgKCoLBYIAQwq1t9gSIySSkAuR631sR67IP67IP67LP7VSXTQGyfv166HQ6VFZW4vXXX8e8efPw5z//2enFuENAgK9038BAPydW4jysyz6syz6syz63U102BYhOpwMAeHt7IzExEZMmTcLs2bNRWFgIo9FoPqRUVFQEnU4HIYRb2+xRXFwulcSBgX44f77M7n6uxrrsw7rsw7rs0xjrUqtV9W54Ww2QK1euwGg0ws/PD0IIZGZmQq/XIyAgAHq9HhkZGRg+fDgyMjKg1+vNh5Pc3UZEtychBC5ePI/Kyt8BePbwUVGRGiaTyaM11MV6XSp4ezdBq1aBUKlUNr+v1ZPoZ86cwdSpU2E0GmEymRAWFoY5c+YgKCgIubm5SEpKQmlpKfz9/ZGamooOHToAgNvbbMU9EPdgXfZhXfa5sa6yskuoqrqGli0DoFJ59tY2jUaNqqpbL0Cs1SWECZcuXYBG4w0/v5Y12iztgdh0FVZjwgBxD9ZlH9ZlnxvrKio6C602GBqNl4erargBAgBVVddQUlKIoKA2NV63FCC8E52IGjSTyQhFsfmCUqqHomhgMhnt6sMAIaIGz57j9lQ3mTFkbBO5gZePBpYOIPxWXgHFp/5/jmoA1yqqnF5XY2VtvGXZ+j1UVVXh739fjd27d0Gj0UAIE/r0eQCTJk3F6dOn8O677yA//wxMJoFOnTph6tQZCA4OMffftWsnNm5ch4qKCqhUKnTseDcmTZqGkJAQlJaWIi3tbRw48CMURUGrVi0xceJU3HdfDxd8YssYIERuYAKQvPK7etu9NGpcs3CMet5f+rqgqsbL2njLsvV7WLjwNVRU/I41a9ahWbPmqKqqwo4dn6G4+AJeeOE5vPDCy4iOjgEAbNq0HjNmTMH//u9H0Gg02L49HZs2rcff/vY/aNu2HQDgwIH9KCm5gJCQEMydm4SwsDB89NEnUBQFBw/+iFdffRkrVqxFmzZtnf6ZLeEhLCIiJzpz5jT27v0nZs2ai2bNqqcA0Wg0GD58JDIzt6NHj57m8ACAhIQ/onlzX+zenQUAWLv2fUydOsMcHgDQs2cE7rmnKw4dOoAzZ37F5MnTzLNy9OjRC3Fxw7Bu3Vo3fspqDBAiIic6ceI42rRpB39//1ptubk56NLl3lqv33NPV5w8mYOLF0tQVFSIe+7pWud75+bmoFOnztBoah486tLlXpw8meOcD2AHBggRkVPVf5uAtbsmHG13NwYIEZEThYd3xtmzp1FaWlqrrWPHcBw9+nOt17OzjyAsrCO02gAEBgbh2LGjdb53x47hOH78F1RV1TyRf/TozwgL6+icD2AHBggRkRO1bdsODzzwIN58cyGuXLkMADAajdi8eSOGDBmKAwd+xJ49u83Lb9q0HmVlpXj44cEAgD/96RksW/YW8vPPmpfZt+87HD16BN2790SbNm3x3nvvwGisvmfj0KED2LHjU4wd+7QbP2U1XoVFRORkc+a8hjVrVmHcuLHw8tJACIE+fR7AHXfcgSVL0pCW9jZWrFgGIYC77w7HkiVp5vMajz76GHx8fDBnzkxUVFRArVYjLOxuTJ78PABgwYJUvPvu2xg9egQURYMWLVpg/vzUGifd3YVTmdioIUzpcCthXTUpPhqHL+M1euA+kIbwPZ479ytCQu6s0e6p+0Aa8lQmQN1j6dBsvEREDY2rbrq0b6KPxo/nQIiISAoDhIiIpDBAiIhICgOEiIikMECIiEgKA4SIiKTwMl4ianT8mgioXXAniAlqlP1u24OXSktL8eijgzF8+GOYNu3FepfbvHkDHn54MFq10gIAMjO3Y+nS/0FISKh5mcjIvpg0aapdtS5aNB9DhsS79DkhDBAianTUMKFgw3ynv29o4lwAik3LfvHFTnTpci92787C5MnPw8ur5jPbTSYTVCoVNm/eiIiI3uYAAYCIiN5YsOANh2pNSprrUH9bMECIiFxgx47PMHnyNKxb93f8619fYcCAGHzwwUrk55/F1atXkJ9/FgMHDsKFC+cxZ84seHv7ICVlgcX3/OCDlTh9+hQuX76MM2dOo1MnPcaM+RPeffdtnDtnwEMPReO556YBAKZMmYAnnxyLBx6IQnr6x9i4cT28vLwhhAnz5i3CnXe2d/gzMkCIiJwsJ+cESktL0avX/SgpKcaOHZ9hwIDqh0gdOnQAa9asR8uWLQEA27enY8GCVHToUD2b7rFjR7F//7/x5z8nmt/vsceewNChjwIAjh//BatXr0PTpk0xbtwYrFjxLhYvXgqj0YhRo4Zh2LARtebFWrbsHXz44UcIDg5BZWUlTCbnHN5jgBAROdmOHZ9i8OBHoFKp8NBDA7BkyZs4f74IANC37wPm8KiPpUNYvXv3ga9v9dxUHTt2RFhYOLy9vQEA7drdifz8s7UCJCLifixcOA9RUQ+ib9/+aN26jYOfsBoDhIjIia5du4Yvvvgc3t4++PzzHQCAqqoq7NyZAQBo2rSZQ+/v7e1j/rtarcDHx/uGn9Xmad5vtGjRYvz888/48cf9eP75iXjppdno2/cBh+oAGCBERE61d++XaNeuPZYv/8D82pEjh7FgQYr5mR83at68OcrLy11WT1VVFc6dq35M7j33dEVBwVnk5BxngBAR1cUE9X+umHL++1qTmbkdgwYNqfFa167dYDKZ8NNPBxEe3rlG2+OPj8bChfPQpEkT80n0m8+BdO6sl76qymQyYf78FJSVlUGlUiM4OBgTJ06Req+b8XkgNmoIz0W4lbCumvg8EOey9jwQT7ndngfCO9GJiEgKA4SIiKQwQIiowbvNjsS7hMwYMkCIqEFTqxUYje4/P9TYGI1VUKttm6blOgYIETVoTZv6oqzsEoS49U5eNxRCmFBWdhFNm9Z9srw+vIyXiBo0X98WuHjxPAoLzwLw7KEstVrttGlCnMl6XSp4ezeBr28Lu96XAUJEDZpKpYJWG+TpMgA0jMuencmuQ1jvvvsuOnXqhBMnTgAA8vLykJCQgNjYWCQkJODUqVPmZd3dRkRE7mVzgBw9ehSHDh1CaOh/H3KSkpKCxMREZGVlITExEcnJyR5rIyIi97IpQCorKzFv3jykpKRApap+GldxcTGys7MRHx8PAIiPj0d2djZKSkrc3kZERO5n0zmQd955B8OGDUPbtm3NrxkMBgQHB0NRqi/7UhQFQUFBMBgMEEK4tU2r1YKIiNzLaoAcPHgQP//8M1566SV31ONy9c3pYovAQD8nVuI8rMs+nqjrt/IKeGks7/BbalfUamg9NJ78Hu1zO9VlNUB++OEH/N///R8GDhwIADh37hyeeeYZzJ49G4WFhTAajVAUBUajEUVFRdDpdBBCuLXNHpxM0T1YV02Kj8biZInWJlM0mkweqZvfo30aY10OTaY4YcIE/Otf/8KePXuwZ88ehISE4IMPPkBcXBz0ej0yMqofkpKRkQG9Xg+tVouAgAC3thERkfvZPZ17dHQ0VqxYgfDwcOTm5iIpKQmlpaXw9/dHamoqOnToAABub7MV90Dcg3XVxOncnYt12cdVeyB8HoiNGuMvhiuxrpoYIM7FuuzjsUNYREREdWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUmwJk8uTJGDZsGB599FEkJibi2LFjAIC8vDwkJCQgNjYWCQkJOHXqlLmPu9uIiMi9bAqQ1NRUfPbZZ0hPT8e4cePwyiuvAABSUlKQmJiIrKwsJCYmIjk52dzH3W1EROReNgWIn5+f+e/l5eVQqVQoLi5GdnY24uPjAQDx8fHIzs5GSUmJ29uIiMj9NLYu+Oqrr+Kbb76BEAKrV6+GwWBAcHAwFEUBACiKgqCgIBgMBggh3Nqm1WqdOihERGSdzQHy+uuvAwDS09PxxhtvYNq0aS4rypUCAnyl+wYG+llfyANYl308Uddv5RXw0lje4bfUrqjV0HpoPPk92ud2qsvmALnu0UcfRXJyMkJCQlBYWAij0QhFUWA0GlFUVASdTgchhFvb7FFcXA6TSdj7sREY6Ifz58vs7udqrMs+nqpL8dHgWpWp3nYvjdpiu9Fk8kjd/B7t0xjrUqtV9W54Wz0HcvnyZRgMBvPPe/bsQYsWLRAQEAC9Xo+MjAwAQEZGBvR6PbRardvbiIjI/VRCCIub4xcuXMDkyZNx9epVqNVqtGjRArNmzUKXLl2Qm5uLpKQklJaWwt/fH6mpqejQoQMAuL3NVtwDcQ/WVZPio0Hyyu/qbbe2BzLvL31hrKhyRWkW8Xu0T2Osy9IeiNUAaWwYIO7BumpigDgX67KPxw5hERER1YUBQkREUhggREQkhQFCRERSGCBERCSFAUJERFIYIEREJIUBQkREUhggREQkhQFCRERSGCBERCSFAUJERFIYIEREJIUBQkREUhggREQkhQFCRERSGCBERCSFAUJERFIYIEREJIUBQkREUhggREQkhQFCRERSGCBERCSFAUJERFIYIEREJIUBQkREUhggREQkhQFCRERSGCBERCSFAUJERFIYIEREJIUBQkREUhggREQkhQFCRERSrAbIxYsX8eyzzyI2NhZDhw7FlClTUFJSAgDIy8tDQkICYmNjkZCQgFOnTpn7ubuNiIjcy2qAqFQqjB8/HllZWdi+fTvatm2LxYsXAwBSUlKQmJiIrKwsJCYmIjk52dzP3W1EROReVgOkZcuWiIyMNP/cvXt3FBQUoLi4GNnZ2YiPjwcAxMfHIzs7GyUlJW5vIyIi99PYs7DJZMLGjRsRHR0Ng8GA4OBgKIoCAFAUBUFBQTAYDBBCuLVNq9U6bUCIiMg2dgXI/Pnz0axZM4wZMwbZ2dmuqsmlAgJ8pfsGBvo5sRLnYV328URdv5VXwEtjeYffUruiVkProfHk92if26kumwMkNTUVv/76K1asWAG1Wg2dTofCwkIYjUYoigKj0YiioiLodDoIIdzaZo/i4nKYTMLugQoM9MP582V293M11mUfT9Wl+GhwrcpUb7uXRm2x3WgyeaRufo/2aYx1qdWqeje8bbqMd8mSJThy5AjS0tLg7e0NAAgICIBer0dGRgYAICMjA3q9Hlqt1u1tRETkfiohhMXN8ZycHMTHx6N9+/Zo0qQJAKBNmzZIS0tDbm4ukpKSUFpaCn9/f6SmpqJDhw4A4PY2W3EPxD1YV02KjwbJK7+rt93aHsi8v/SFsaLKFaVZxO/RPo2xLkt7IFYDpLFhgLgH66qJAeJcrMs+Hj2ERUREdDMGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEBGRFAYIERFJsRogqampiI6ORqdOnXDixAnz63l5eUhISEBsbCwSEhJw6tQpj7UREZH7WQ2QgQMHYv369WjdunWN11NSUpCYmIisrCwkJiYiOTnZY21EROR+VgMkIiICOp2uxmvFxcXIzs5GfHw8ACA+Ph7Z2dkoKSlxexsREXmGRqaTwWBAcHAwFEUBACiKgqCgIBgMBggh3Nqm1Wrtqj0gwFfmIwMAAgP9pPu6Euuyjyfq+q28Al4ay9trltoVtRpaD40nv0f73E51SQVIQ1ZcXA6TSdjdLzDQD+fPl7mgIsewLvt4qi7FR4NrVaZ62700aovtRpPJI3Xze7RPY6xLrVbVu+EtFSA6nQ6FhYUwGo1QFAVGoxFFRUXQ6XQQQri1jYiIPEPqMt6AgADo9XpkZGQAADIyMqDX66HVat3eRkREnqESQlg8nrNgwQLs2rULFy5cQKtWrdCyZUvs2LEDubm5SEpKQmlpKfz9/ZGamooOHToAgNvb7MFDWO7BumpSfDRIXvldve3WDmHN+0tfGCuqXFGaRfwe7dMY67J0CMtqgDQ2DBD3YF01MUCci3XZx1UBwjvRiYhICgOEiIikMECIiEgKA4SIiKTcdjcSEnlCc6UKKWO61L+ASgVYuJ6luVKFUhfUReQIBgiRG6iEETlrU+pvV6lg6YLIiOcXAVBcUBmRPB7CIiIiKQwQIiKSwgAhIiIpDBAiIpLCACEiIikMECIiksIAISIiKQwQIiKSwgAhIiIpDBAiIpLCACEiIimcC4uIrPJrIqBG/U9MtMYENcp+VzmxIroVMECIyCo1TCjYMF+6f2jiXHAyyMaHAUJEjR73oFyDAUJEjZ6je1BtxiSjRRPrAWS8/BtaNKk9LX9jDSAGCNFtwMtHI7X9/Vt5BRQfDVQqo9NralCEsCmANBoFVVW1x6qxHsJjgBDdBkwAkld+Z3c/L40a16pMeGtST+cXZYebD0HVt6VfH7WHN/7VahVaNJEP4Vt1D4YBQkS3vJsPQdW3pV+fNn+c64qybGfjHkx9btU9GAYIEbmco1vgnt6DoLoxQIjI9RzcAvf4HgTViXeiExGRFAYIERFJ4SEssom9N2LdfJWMo1eRyF6Gep0awLWKKgfegYhuxgAhm9h7I9bNV8k4ehVJU6UKpaVXpPs392+Ga9K9iaguDBBqEFTCiJy1KdL9I55fhFvxMkiihowBcptwdC4gRy+jdPgyTsdWT0QuwABpIOoLAFvvyFWrgLPrPXgZpYcv41SrqgPM3juYr7tV7wR2FxVUUDm4FeHM/kaTyeH3I8cxQBqI+s5B2HpH7m1/Hf1/AszeO5ivs3Uyvfo4ugd1PQCl+6sFUsZ0sb+jSgUIARUE8s+XS6+/NeDU/iqVCkLYviHQWnrNtwZH9+CNv192YjX/1eACJC8vD0lJSbh06RJatmyJ1NRUtG/f3tNlWeXpQ0hUvQUrveUqBAwfLZBed+sn50j3vb5+R/fgZM4hXf+Puvfzi6TXTU7g4PffdkwyXHEguMEFSEpKChITEzF8+HB8+umnSE5OxocffujpsqxyeDrpW2APwp7/eG/FQwz558vt3nK9zhlb0ESNTYMKkOLiYmRnZ2Pt2rUAgPj4eMyfPx8lJSXQarU2vYfagf/UHOkLlRoa31ZO769oFMCWQzJOWP+FSh/bF68+8mHWWqWGxt+276i+9fu0CHC4/811uXv99TZbq8tD42euy8Wf397+dn+PThg/W/791Pvv0UX//m3vr5L+/8tSP5WQ2RzzkCNHjmDWrFnYsWOH+bW4uDi8+eab6NJF4vguERFJ49WRREQkpUEFiE6nQ2FhIYzG6l1Eo9GIoqIi6HQ6D1dGRHT7aVABEhAQAL1ej4yMDABARkYG9Hq9zec/iIjIeRrUORAAyM3NRVJSEkpLS+Hv74/U1FR06NDB02UREd12GlyAEBHRraFBHcIiIqJbBwOEiIikMECIiEgKA4SIiKQ0qKlMXOnTTz/F6tWrkZubi1deeQVjxoypd9nNmzfj/fffhxACDz74IObMmQO1Wm21TcbVq1cxe/ZsHD16FIqiYNasWRgwYECt5T788EN8/PHH5p/PnDmDUaNGYfbs2di3bx8mTJhgnnTS29sbW7Zska7JnrqsrdtT47V792689957qKyshBACjz32GMaNG2dTzfawZfJPo9GIBQsW4Ouvv4ZKpcKECRMwatQoq22OsKWutLQ0ZGZmQlEUaDQaTJ8+HVFRUQCAZcuWYcOGDQgKCgIA9OzZEykp8g/8sqcuS+v25HjNnDkTx48fN/98/PhxpKWlYeDAgS4Zr9TUVGRlZSE/Px/bt29HeHh4rWVc/rslSAghxPHjx0VOTo54+eWXxbp16+pd7vTp0yIqKkoUFxcLo9Eoxo0bJ7Zt22a1TdayZcvEK6+8IoQQIi8vT/Tr10+Ul5db7FNZWSn69OkjDh8+LIQQ4vvvvxcjRoxwqA7Zuiyt25PjdejQIXHu3DkhhBClpaUiJiZG/PDDD1ZrttfYsWNFenq6EEKI9PR0MXbs2FrLbNu2TYwbN04YjUZRXFwsoqKixJkzZ6y2ubquvXv3iitXrgghhDh27Jjo1auXuHr1qhBCiKVLl4pFixY5XIdMXZbW7cnxutGxY8dE7969RUVFhdWaZf3www+ioKBADBgwQBw/frzOZVz9u8VDWP8RHh6Ojh07Wt36zcrKQkxMDLRaLdRqNUaNGoXMzEyrbbJ27tyJ0aNHAwDat2+Prl27Yu/evRb7/POf/8Qdd9yBe++916F1O7uum3lyvO677z4EBwcDAPz8/BAWFob8/HyH1n2z65N/xsfHA6ie/DM7OxslJSU1lsvMzMSoUaOgVquh1WoRExODzz//3Gqbq+uKiopC06ZNAQCdOnWCEAKXLl1yaN3OqMsST47XjbZu3YqhQ4fC29vboXVbEhERYXUWDlf/bjFA7GQwGBAaGmr+OTQ0FAaDwWqbrIKCArRu/d/JwHU6Hc6dO2exz8cff4zHHnusxmunTp3CiBEjMGrUKGzbts2hmuytq7513yrjlZubi0OHDqFPnz5Wa7aHwWBAcHAwFKX6WeyKoiAoKKjWZ7x5HG6s2VKbLFvrulF6ejratWuHkJAQ82s7duzA0KFDMW7cOBw8eNChmuytq7513wrjVVlZie3bt9f6N+js8bKFq3+3bptzICNGjEBBQUGdbd9++635l8PdrNVlr6KiInz//ff429/+Zn6tS5cu+Oqrr+Dn54czZ87g6aefRnBwMPr16+fyumTWbYkrxmvy5MlITk4275E4u+aG7t///jfeeecdrFmzxvza6NGjMXHiRHh5eeGbb77B5MmTkZmZiVatHJhy3EaeXLctdu/ejdDQUOj1evNrt3rNsm6bAHHGVjdQndI3/gdWUFBg3o201CZbV2hoKPLz883zfRkMBkRGRta7fHp6Oh566KEa84P5+vqa/962bVvExMTgwIEDFv9DdFZdltbt6fEqLi7G008/jfHjxyMuLs6mmu1x4+SfiqLUO/nn9XHo1q2buebrW4aW2mTZWhcAHDx4EC+//DLee++9GlMGBQYGmv/+wAMPQKfTIScnB71793Z5XZbW7enxAuo+AuCK8bK1dlf+bvEQlp1iY2Oxe/dulJSUwGQyYcuWLRgyZIjVNlmDBw/Gpk2bAFQfVvn555/NV8LU5ZNPPqn1y1tUVGR+Ct+lS5fwzTffoHPnzm6py9K6PTleFy9exNNPP40//vGPta48cdZ42Tr55+DBg7FlyxaYTCaUlJRg9+7diI2Ntdomy9a6Dh8+jOnTp2Pp0qW1nrdTWFho/vuxY8eQn5+Pu+66yy11WVq3J8cLAM6dO4cff/zRfL7ElppdyeW/Ww5dBtCIbN++XURFRYn77rtPREREiKioKJGTkyOEEOLtt98WGzZsMC+7ceNGMXDgQDFw4ECRnJwsqqqqbGqTcfnyZTF16lQRExMjBg0aJL744gtz28117d+/X/Tv37/WOtetWyfi4uLEsGHDxCOPPCJWrVrlUE321GVt3Z4ar0WLFol7771XDBs2zPxn69atNtVsj5MnT4rHH39cDBo0SDz++OMiNzdXCCHE+PHjzVfJVVVVieTkZPM4fPTRR+b+ltocYUtdI0eOFJGRkTXG6JdffhFCCDFz5kzxyCOPiKFDh4qRI0eKL7/80m11WVq3J8dLCCHee+898cILL9Tq74rxmj9/voiKihJ6vV7069dPxMXF1arJ1b9bnEyRiIik8BAWERFJYYAQEZEUBggREUlhgBARkRQGCBERSWGAEFmRnJyMtLQ0T5dBdMvhZbzUIO3fvx+LFy9GTk4OFEVBhw4d8Morr5jvqpX1ySefYMuWLdi4caOTKpW3bNky/Prrr1i8eHG9y7hqHIhscdtMZUKNR3l5OSZOnIi//vWvGDJkCK5du4b9+/e7dObTW5G7xuH6FB5EN+MhLGpw8vLyAFRPq60oCpo0aYL+/fvXmG5k69atGDJkCO6//34888wzNaZq79SpEzZu3IhBgwbh/vvvx2uvvQYhBHJzc5GSkoJDhw6hR48eiIiIAAAkJSVhyZIlAKofNvXggw/i/fffR9++fdG/f3/s3r0bX331FWJjY9G7d2+sWLHCvC6TyYRVq1YhJiYGkZGRmDZtmnlK9LNnz6JTp07Ytm0b/vCHPyAyMhLLly8HAOzduxcrV67Ezp070aNHDwwbNkxqHDZv3owhQ4agR48eiIuLw9GjRwFUz0A8duxYRERE4JFHHsE//vEPc5+kpCSkpKTg2WefRffu3bFv3z4UFhZi6tSp6NOnD6Kjo/Hhhx+alz98+DBGjhyJnj17ol+/fjUm8qRGzuH76YncrKysTPTu3VvMnDlTfPnll+LSpUs12r/44gsRExMjTp48Ka5duybS0tJEQkKCuT08PFxMmDBB/PbbbyI/P19ERkaKr776SgghxMcffyxGjx5d4/1mzZol3nrrLSFE9cOm9Hq9WLZsmaisrBSbNm0SkZGRYsaMGaKsrEycOHFCdO3aVZw+fVoIIcTatWvFqFGjhMFgEBUVFWLu3Lli+vTpQgghzpw5I8LDw8Wrr74qrl69Ko4dOya6dOkiTp48KYSofgjRiy++KD0OmZmZon///uKnn34SJpNJnDp1Spw9e1ZUVlaKmJgYsXz5clFRUSG+/fZb0b17d/P0HLNmzRI9e/YU+/fvF0ajUVy5ckWMGDFCLFu2TFRUVIjTp0+L6OhosXfvXiGEEE888YT5QWDl5eXi4MGDNn+X1LBxD4QaHF9fX2zYsAEqlQpz585F3759MXHiRFy4cAEA8NFHH2HChAkICwuDRqPBxIkTzRPYXffss8/C398foaGhiIyMxC+//GLz+jUaDSZNmgQvLy/ExcXh4sWLeOqpp+Dr64u7774bd999t/nRpps2bcL06dMREhICb29vTJkyBVlZWaiqqjK/35QpU9CkSRN07twZnTt3trkWa+OwdetWjB8/Ht26dYNKpcKdd96J1q1b46effsKVK1cwYcIEeHt7o2/fvhgwYAB27Nhhfu+BAweiV69eUKvVOHHiBEpKSjBlyhR4e3ujbdu2eOKJJ8wP/9JoNDh9+jRKSkrQvHlzdO/e3eaxpIaN50CoQQoLC8OiRYsAVB+Oefnll7Fw4UK89dZbKCgowMKFC5GammpeXgiBwsJC88Ombpxeu2nTprh8+bLN627ZsqX5nECTJk0AVM/Yep2Pj4/5/QoKCvDcc8/VeNKlWq1GcXGx+ec77rijRi1XrlyxuRZL42AwGNCuXbtafYqKihASElKjptDQ0Bozxt44VXl+fj6KiorMh/SA6vMi139+/fXXsXTpUgwZMgRt2rTBlClT6nwOPTU+DBBq8MLCwjBy5EjzNO46nQ4TJ06s87yBNSqVyqm1hYSEYOHChejVq1ettrNnzzq1lrrG4fTp07WWCwoKwrlz52AymcwhYjAY0L59+zrfV6fToU2bNti1a1ed7e3bt8dbb70Fk8mEXbt24fnnn8e+ffvQrFkzu+qnhoeHsKjByc3NxZo1a2o8mjMjIwP33XcfgOqnv61atQo5OTkAgLKyMuzcudOm9w4ICEBhYSEqKyudUuuTTz6Jt99+23z47PpzF2ytJT8/HyaTqc52a+Pw+OOPY82aNThy5AiEEPj111+Rn5+Pbt26oWnTpli9ejWuXbuGffv2Yc+ePTUeqnWjbt26wdfXF6tWrcLvv/8Oo9GIEydO4PDhwwCATz/9FCUlJVCr1fD39wcAXrV1m+AeCDU4vr6++Omnn7B27VqUlZXBz88PAwYMwMyZMwEADz/8MC5fvowZM2YgPz8ffn5+6Nevn00Pq+rTpw86duyI/v37Q6VSYd++fQ7V+tRTT0EIgXHjxqGoqAgBAQGIi4tDTEyM1b6DBw/GZ599hsjISLRp06bW0xitjcOQIUNw6dIlvPjiiygqKkLr1q3xxhtvoHXr1li+fDlee+01rFy5EsHBwXjjjTcQFhZWZx2KomD58uVITU3FwIEDUVlZibvuugsvvPACAODrr7/GokWL8PvvvyM0NBRLliyBj4+PQ+NGDQNvJCQiIik8hEVERFIYIEREJIUBQkREUhggREQkhQFCRERSGCBERCSFAUJERFIYIEREJIUBQkREUv4fqDfqHhs/sEQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig= plot_overlayed_two_histograms(sentiment_scores['COCO'], \n",
    "                              sentiment_scores['ArtEmis'], \n",
    "                              min_val=-1, max_val=1, n_bins=20, labels=['COCO', 'ArtEmis']);\n",
    "fig.axes[0].set_xlabel('Sentiment Scores')\n",
    "fig.savefig('ArtEmis_vs_COCO_sentiment_scores.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Subjectivity Analysis\n",
    "##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def subjectivity(utterance):\n",
    "    testimonial = TextBlob(utterance)\n",
    "    return testimonial.sentiment.subjectivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(TextBlob('The painting is red').sentiment.subjectivity)\n",
    "print(TextBlob('The painting is nice').sentiment.subjectivity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "subjectivity_scores = dict()\n",
    "for dset_name in datasets:    \n",
    "    subjectivity_scores[dset_name] = df_parallel_column_apply(datasets[dset_name], subjectivity, 'utterance_spelled')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19\n",
      "0.02\n",
      "0.47\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "print(subjectivity_scores['COCO'].mean().round(2))\n",
    "print(subjectivity_scores['COCO'].median().round(2))\n",
    "\n",
    "print(subjectivity_scores['ArtEmis'].mean().round(2))\n",
    "print(subjectivity_scores['ArtEmis'].median().round(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_overlayed_two_histograms(subjectivity_scores['COCO'], \n",
    "                              subjectivity_scores['ArtEmis'], \n",
    "                              min_val=0, max_val=1, n_bins=20, labels=['COCO', 'ArtEmis']);\n",
    "fig.axes[0].set_xlabel('Subjectivity Scores')\n",
    "fig.savefig('ArtEmis_vs_COCO_subjectivity_scores.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Analyze the above metric per art-genre\n",
    "##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'ArtEmis'\n",
    "datasets[name]['conreteness_scores'] = concreteness_scores[name]    \n",
    "datasets[name]['subjectivity_scores'] = subjectivity_scores[name]\n",
    "datasets[name]['sentiment_abs_scores'] = sentiment_scores[name].abs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = pd.read_csv('../../data/wiki_art_genre_class.csv')\n",
    "m = pd.merge(datasets['ArtEmis'], g, on=['art_style', 'painting'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pallete = plt.cm.Pastel1_r\n",
    "\n",
    "for metric in ['conreteness_scores', 'subjectivity_scores', 'sentiment_abs_scores']:\n",
    "    for stat in ['average', 'median']:\n",
    "        \n",
    "        if stat == 'average':\n",
    "            s = m.groupby('genre')[metric].mean().sort_values()\n",
    "        else:\n",
    "            s = m.groupby('genre')[metric].median().sort_values()\n",
    "            \n",
    "        fig = plt.figure()\n",
    "        norm = plt.Normalize(s.min(), s.max())\n",
    "        colors = pallete(norm(s.values))                \n",
    "        ax = s.plot.barh(grid=True, color=colors, ec=\"k\", fontsize=12)        \n",
    "\n",
    "        name_of_metric = metric.split('_')[0].capitalize()\n",
    "        \n",
    "        if metric == 'sentiment_abs_scores':                        \n",
    "            xlabel = '{} (absolute) Sentiment per Genre'.format(stat.capitalize())\n",
    "        else:            \n",
    "            xlabel = '{} {} per Genre'.format(stat.capitalize(), name_of_metric)        \n",
    "        \n",
    "        ax.set_xlabel(xlabel)\n",
    "        plt.tight_layout()        \n",
    "        fig.savefig('ArtEmis_{}_per_Genre_{}.jpg'.format(name_of_metric, stat.capitalize()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "##\n",
    "## Analyze basic linguistic elements: Part-Of-Speech\n",
    "##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "for df in datasets.values():\n",
    "    df['pos'] = nltk_parallel_tagging_of_tokens(df.tokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ArtEmis\n",
      "Nouns 4.0\n",
      "Pronouns 0.9\n",
      "Adjectives 1.6\n",
      "Adpositions 1.9\n",
      "Verbs 3.0\n",
      "COCO\n",
      "Nouns 3.7\n",
      "Pronouns 0.1\n",
      "Adjectives 0.8\n",
      "Adpositions 1.7\n",
      "Verbs 1.2\n"
     ]
    }
   ],
   "source": [
    "# (raw numbers of Table.1 in main papeer)\n",
    "for dataset_name, df in datasets.items():\n",
    "    print(dataset_name)\n",
    "    pos_analysis(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below group the utterances first along each image (stimulus).\n",
    "# Numbers of Table.2 in main paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "14466a061c5f4bd4a861d0e7369ba5fd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/80031 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nouns 18.7 3.4\n",
      "Pronouns 3.1 0.6\n",
      "Adjectives 8.3 1.5\n",
      "Adpositions 6.5 1.2\n",
      "Verbs 13.4 2.4\n"
     ]
    }
   ],
   "source": [
    "pos_analysis(datasets['ArtEmis'], group_cols=['painting', 'art_style'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d748778aa12f4abf97973c9c52e5eb64",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=25799.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Nouns 7.8 2.2\n",
      "Pronouns 0.4 0.1\n",
      "Adjectives 2.8 0.8\n",
      "Adpositions 2.9 0.8\n",
      "Verbs 2.3 0.6\n"
     ]
    }
   ],
   "source": [
    "pos_analysis(datasets['GoogleRefxp'], group_cols=['image_id'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "87077ba48867466c9b420817bc1162b0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/123287 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nouns 10.8 2.2\n",
      "Pronouns 0.6 0.1\n",
      "Adjectives 3.3 0.7\n",
      "Adpositions 4.5 0.9\n",
      "Verbs 4.5 0.9\n"
     ]
    }
   ],
   "source": [
    "pos_analysis(datasets['COCO'], group_cols=['image'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "331bc801be98473fa6f9a093a903d760",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=31783.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Nouns 12.9 2.6\n",
      "Pronouns 0.8 0.2\n",
      "Adjectives 4.0 0.8\n",
      "Adpositions 4.9 1.0\n",
      "Verbs 6.4 1.3\n"
     ]
    }
   ],
   "source": [
    "pos_analysis(datasets['Flickr'], group_cols=['image_id'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "artemis",
   "language": "python",
   "name": "artemis"
  },
  "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.12"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}