From 9c461a32bb793e15f22df8b814232b8716492057 Mon Sep 17 00:00:00 2001
From: ds-ramon <89653079+ds-ramon@users.noreply.github.com>
Date: Wed, 18 May 2022 09:01:06 -0700
Subject: [PATCH] adding a NER_evaluator

This notebook contains the NER_evaluator class and will be updated to include more results from EDA and NER_model experiments
---
 .../notebooks/evaluation/NER_eval.ipynb       | 649 ++++++++++++++++++
 1 file changed, 649 insertions(+)
 create mode 100644 gamechangerml/experimental/notebooks/evaluation/NER_eval.ipynb

diff --git a/gamechangerml/experimental/notebooks/evaluation/NER_eval.ipynb b/gamechangerml/experimental/notebooks/evaluation/NER_eval.ipynb
new file mode 100644
index 00000000..d2f0c1f9
--- /dev/null
+++ b/gamechangerml/experimental/notebooks/evaluation/NER_eval.ipynb
@@ -0,0 +1,649 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "13967883",
+   "metadata": {},
+   "source": [
+    "# Named Entity Evaluator Class"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d17e19ce",
+   "metadata": {},
+   "source": [
+    "#next steps\n",
+    "\n",
+    "- write tests for methods\n",
+    "- improve partial text matching method\n",
+    "    - any overlap\n",
+    "    - overlapping more than x characters\n",
+    "    - is an entity contained in the prediction\n",
+    "\n",
+    "- improve spurious counting method\n",
+    "- fix spans mismatch\n",
+    "\n",
+    "#design\n",
+    "- check if display needs to be moved to a separate class (w/ respect to single responsibility)\n",
+    "- check on the usage of side effects on class variables\n",
+    "- turn some methods and variables to private\n",
+    "- create getters for the metric dictionaries\n",
+    "\n",
+    "#performance\n",
+    "- improve speed\n",
+    "    - profile method calls vs using self.variables\n",
+    "\n",
+    "#explore\n",
+    "- weighted recall based on prevelance\n",
+    "\n",
+    "Notes to explain:\n",
+    "\n",
+    "- impact of TN on metrics chosen \n",
+    "- impact of spurious on metrics chosen\n",
+    "- add visualizations\n",
+    "- what accounted for most spurious"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 273,
+   "id": "e4979f7f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import json\n",
+    "from collections import Counter\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17214e85",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "04e79949",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = open(\"./ner_finetune_model_results_20220414.json\")\n",
+    "\n",
+    "\n",
+    "data = json.load(d)\n",
+    "results = json.loads(data)\n",
+    "\n",
+    "original_df=pd.DataFrame(results).T\n",
+    "df=original_df\n",
+    "\n",
+    "# Separate Fake and Real Documents\n",
+    "real_rows=[name for name in original_df.index if 'FAKE' not in name]\n",
+    "fake_rows=[name for name in original_df.index if 'FAKE' in name]\n",
+    "\n",
+    "real_df=df.drop(index=fake_rows)\n",
+    "fake_df=df.drop(index=real_rows)\n",
+    "\n",
+    "\n",
+    "df=real_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db36143d",
+   "metadata": {},
+   "source": [
+    "## Purpose:\n",
+    "\n",
+    "\n",
+    "    The purpose of this experiement is to explore the varouis approaches and considerations in the evaluation of Named Entity Recognition models.\n",
+    "\n",
+    "## Challenges\n",
+    "    Major challenges faced included determining a threshold for counting partial entities, the nature of true negative samples in NER, determining false positive entities, and comparing the validity of alternative forms of calculating specific metrics.\n",
+    "\n",
+    "\n",
+    "    Base counts include:\n",
+    "    - text matches \n",
+    "    - partial matches\n",
+    "    - exact matches\n",
+    "    - label matches\n",
+    "    - missed entities\n",
+    "    - missed entities with no predictions\n",
+    "    - label only matches\n",
+    "    - spurious entities (False Positive)\n",
+    "    - counts of the actual entity being found inside of a predicted entity during a partial match\n",
+    "    - counts of the predicted entity being found inside of an actual entity during a partial match\n",
+    "    \n",
+    "## Metrics\n",
+    "    The NER_Model_Evaluator is a class constructed to gain insight into the performance of NER tasks by counting relevant occurances in the text and leveraging those counts to produce various scores.\n",
+    "\n",
+    "    The NER_Model_Evaluator currently provides a count of:\n",
+    "    - Documents with the most missed entities\n",
+    "    - Most frequently missed Entities\n",
+    "    - Most common Entities\n",
+    "    \n",
+    "    The NER_Model_Evaluator currently leverages counts to provide scores that include:\n",
+    "    - Recall\n",
+    "    - Recall considering partial matches\n",
+    "    - False Discovery Rate\n",
+    "    - False Negative Rate\n",
+    "    - Jaccard Index"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 253,
+   "id": "f2347b20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class NER_Model_Evaluator:\n",
+    "   \n",
+    "    # init method or constructor \n",
+    "    def __init__(self, eval_data):\n",
+    "        self.eval_data = eval_data\n",
+    "        \n",
+    "        self.original_df=pd.DataFrame(eval_data)\n",
+    "        self.metrics_list=[\"text_matches\",\"records\", \"partial_text\", \"label_matches\", \"actNpred_text\" , \"predNact_text\", \"partial_span\", \"missed\", \"overlaps\", \"spurious\", \"spur_punc\", \"exact_match\", \"text_no_label\", \"pred_overlaps\", \"no_pred\" ] #RC -extract to parameter\n",
+    "        \n",
+    "        self.most_common_entities={}\n",
+    "        self.most_common_missed_entities={}\n",
+    "        self.most_common_missed_docs={}\n",
+    "        self.entity_dict={}\n",
+    "        self.filenames_set={}\n",
+    "        self.metrics_dict={}\n",
+    "        self.missed_entity_dict={}\n",
+    "        self.missed_doc_dict={}\n",
+    "        self.missed_rates={}\n",
+    "        \n",
+    "        \n",
+    "        # Create Getters to retreive variables of interest\n",
+    "    \n",
+    "    \n",
+    "#-----------------------------------------BASIC_COUNTS \n",
+    "    # count expected\n",
+    "    def count_expected(self, df):\n",
+    "        actual_expected_count=0\n",
+    "        for row in df.iterrows():    \n",
+    "            actual_expected_count+=len(row[1]['expected'])\n",
+    "        return actual_expected_count\n",
+    "    \n",
+    "    def count_predictions(self, df):\n",
+    "        predictions_count=0\n",
+    "        for row in df.iterrows():\n",
+    "            predictions_count+=len(row[1]['predicted'])\n",
+    "        return predictions_count\n",
+    "      \n",
+    "#-----------------------------------------   Matching    (True/False)\n",
+    "    def is_spurious(self, row):\n",
+    "        is_spur=True\n",
+    "        for predicted in row[1]['predicted']:\n",
+    "            predicted_range = range(predicted['span'][0], predicted['span'][1]+1)\n",
+    "            for actual_entity in row[1]['expected']:\n",
+    "                expected_range = range(actual_entity['span'][0], actual_entity['span'][1]+1)\n",
+    "                overlap = set(expected_range).intersection(predicted_range)\n",
+    "                in_text= predicted['text'] in (self.entity_dict.keys())\n",
+    "                if overlap or in_text:\n",
+    "                    is_spur=False\n",
+    "            #elif predicted['text'] in string.punctuation:\n",
+    "                #is_spur=True \n",
+    "                #print(predicted['text'])\n",
+    "\n",
+    "                #another function for returning spurious?\n",
+    "                #store spurious entities (to find a relationship with actual and spurious?)\n",
+    "                #print(f\" \\n Spurious entity: {predicted} \\n Actual Entities: {row[1]['expected']}\")\n",
+    "        return is_spur\n",
+    "\n",
+    "\n",
+    "    def is_exact_match(self,actual_entity, predicted):   #maybe remove\n",
+    "        if self.is_text_exact_match(actual_entity, predicted) and self.is_label_match(actual_entity, predicted):\n",
+    "            return True\n",
+    "        return False\n",
+    "    \n",
+    "    def is_text_exact_match(self,actual_entity, predicted):\n",
+    "        if predicted['text'].strip()==actual_entity['text'].strip():\n",
+    "            return True\n",
+    "        return False\n",
+    "\n",
+    "    def is_label_match(self,actual_entity, predicted):\n",
+    "        if predicted['label'] == actual_entity['label']:\n",
+    "            return True\n",
+    "        return False\n",
+    "\n",
+    "#-----------------------------------------   Metrics   \n",
+    "\n",
+    "    ##-----------------------------------------   Pre dictionaries\n",
+    "    \n",
+    "        ##----------------------------------------- base for dictionaries\n",
+    "   \n",
+    "\n",
+    "    \n",
+    "    def make_filenames_set(self,df):\n",
+    "        filename_set=set() #filenames\n",
+    "        for name in df.index:\n",
+    "            filename_set.add(name)\n",
+    "        return filename_set\n",
+    "            \n",
+    "    def make_gold_entity_dict(self,df):\n",
+    "        entity_dict=dict() #gold list entities\n",
+    "        entity_set=set() # replace usage with entity_dict.keys()\n",
+    "\n",
+    "        for row_index, row in enumerate(df.iterrows()): \n",
+    "            #print(f\" Row {row[1]['expected']}\")\n",
+    "            for actual_entity in row[1]['expected']: \n",
+    "                entity_set.add(actual_entity['text'])\n",
+    "                if actual_entity['text'] in entity_dict.keys():\n",
+    "                    #entity_dict[actual_entity['text']]= entity_dict[actual_entity['text']]+1\n",
+    "                    entity_dict[actual_entity['text']]+= 1\n",
+    "                else:\n",
+    "                    entity_dict[actual_entity['text']]= 1\n",
+    "        return entity_dict\n",
+    "                    \n",
+    "                \n",
+    "    #------------------- Depends on pre dicts\n",
+    "    \n",
+    "    def init_missed_entity_dict(self,df):\n",
+    "        self.missed_entity_dict= dict.fromkeys(self.make_gold_entity_dict(df).keys(),0)\n",
+    " \n",
+    "    def init_missed_doc_dict(self,df):\n",
+    "        self.missed_doc_dict= dict.fromkeys(self.make_filenames_set(df),0)\n",
+    "        \n",
+    "        #------------------- Depends on missed dictionaries\n",
+    "        \n",
+    "    def initialize(self,df):\n",
+    "        self.filenames_set=self.make_filenames_set(df)\n",
+    "        self.entity_dict=self.make_gold_entity_dict(df)\n",
+    "        self.init_missed_entity_dict(df)\n",
+    "        self.init_missed_doc_dict(df)\n",
+    "        self.build_metrics_dict(self.original_df)\n",
+    "        \n",
+    "        #print(self.missed_entity_dict)\n",
+    "        #print()\n",
+    "        #print()\n",
+    "        #print()\n",
+    "\n",
+    "    def update_match_metrics(self,actual_entity, predicted, metrics_dict):\n",
+    "        label_match= self.is_label_match(actual_entity, predicted)\n",
+    "        updated_metrics_dict= metrics_dict\n",
+    "        if label_match:\n",
+    "            updated_metrics_dict['label_matches']+=1\n",
+    "        else:\n",
+    "            pass\n",
+    "            # Check if there is an exact match\n",
+    "        exact= self.is_text_exact_match(actual_entity, predicted)\n",
+    "        if exact:\n",
+    "            updated_metrics_dict['text_matches']+=1\n",
+    "            if label_match:\n",
+    "                updated_metrics_dict['exact_match']+=1\n",
+    "            else:\n",
+    "                updated_metrics_dict['text_no_label']+=1\n",
+    "        else:\n",
+    "            updated_metrics_dict['partial_text']+=1\n",
+    "        # check if the actual was in the prediction or of the predicted was in the actual\n",
+    "        if ((predicted['text'] in actual_entity['text']) or (actual_entity['text'] in predicted['text'])) and (predicted['text']!=actual_entity['text']):\n",
+    "            if (predicted['text'] in actual_entity['text']):\n",
+    "                updated_metrics_dict['predNact_text']+=1\n",
+    "            elif (actual_entity['text'] in predicted['text']):\n",
+    "                updated_metrics_dict['actNpred_text']+=1\n",
+    "        return updated_metrics_dict\n",
+    " \n",
+    "    def build_metrics_dict(self,df):\n",
+    "        self.metrics_dict= dict.fromkeys(self.metrics_list,0)\n",
+    "\n",
+    "    \n",
+    "    def process_row(self,row): #adds missed entities and docs\n",
+    "        for actual_entity in row[1]['expected']:\n",
+    "\n",
+    "            max_overlap=0\n",
+    "            best_match_index=None\n",
+    "            expected_range = range(actual_entity['span'][0], actual_entity['span'][1]+1)\n",
+    "            for pred_index, predicted in enumerate(row[1]['predicted']):\n",
+    "\n",
+    "                predicted_range = range(predicted['span'][0], predicted['span'][1]+1)\n",
+    "                overlap = set(expected_range).intersection(predicted_range)\n",
+    "                if len(overlap)>max_overlap:\n",
+    "                    max_overlap=len(overlap)\n",
+    "                    best_match_index=pred_index \n",
+    "                    self.metrics_dict=self.update_match_metrics(actual_entity, predicted,self.metrics_dict)\n",
+    "\n",
+    "            if best_match_index==None:\n",
+    "                self.metrics_dict['missed']+=1\n",
+    "                self.missed_doc_dict[f\"{row[0]}\"]+=1\n",
+    "                self.missed_entity_dict[actual_entity['text']]+=1\n",
+    "    \n",
+    "    ##-----------------------------------------   Post dictionaries    \n",
+    "    \n",
+    "    def make_most_common_entities(self,df):\n",
+    "        self.most_common_entities= dict(Counter(self.entity_dict).most_common(10))\n",
+    "           \n",
+    "    def make_most_common_missed_entities(self,df):\n",
+    "        self.most_common_missed_entities=dict(Counter(self.missed_entity_dict).most_common(10))\n",
+    "          \n",
+    "    def make_most_common_missed_docs(self,df):\n",
+    "        self.most_common_missed_docs=dict(Counter(self.missed_doc_dict).most_common(10))\n",
+    "        \n",
+    "        \n",
+    "    def initialize_most_common(self,df):\n",
+    "        self.make_most_common_entities(df)\n",
+    "        self.make_most_common_missed_entities(df)\n",
+    "        self.make_most_common_missed_docs(df)\n",
+    "        \n",
+    "    ##----------------------------------------- Calculations\n",
+    "    \n",
+    "    def calculate_missed_rates(self,missed_entity_dict): # False Negative Rate (FNR)        \n",
+    "        missed_rates= dict.fromkeys(self.most_common_missed_entities,0)\n",
+    "        #weighted_missed_rates= dict.fromkeys(most_common_missed_entities,0)   \n",
+    "        for key in missed_rates.keys():\n",
+    "            self.missed_rates[f\"{key}\"]= self.most_common_missed_entities[key]/self.entity_dict[key]  #divide by zero exception\n",
+    "            \n",
+    "    #def weighted_missed_rates     \n",
+    "        \n",
+    "    def calculate_false_discovery_rate(self,): #(FDR) \n",
+    "        self.metrics_dict[\"false_discovery_rate\"] = self.metrics_dict[\"spurious\"]/ (self.metrics_dict[\"text_matches\"]+self.metrics_dict[\"spurious\"])\n",
+    "\n",
+    "    def calculate_recall(self): # True Positive Rate\n",
+    "        self.metrics_dict[\"recall\"] = self.metrics_dict[\"text_matches\"]/(self.metrics_dict[\"missed\"]+self.metrics_dict[\"text_matches\"]) #entities got right/ (entities missed+entities_I_got_right)\n",
+    "        \n",
+    "    def calculate_recall_w_partial_matches(self):\n",
+    "        self.metrics_dict[\"partial_recall\"] = (self.metrics_dict[\"text_matches\"]+(0.5*self.metrics_dict[\"partial_text\"]))/(self.metrics_dict[\"missed\"]+self.metrics_dict[\"text_matches\"])\n",
+    "        \n",
+    "    def calculate_jaccard_index(self):\n",
+    "        self.metrics_dict[\"jacaard\"]= self.metrics_dict[\"text_matches\"]/(self.metrics_dict[\"text_matches\"]+self.metrics_dict[\"missed\"]+self.metrics_dict[\"spurious\"])\n",
+    "    \n",
+    "    \n",
+    "    def display_dict(self,dictionary):\n",
+    "        for x in dictionary:\n",
+    "            print(f\" {x} : {dictionary[x]}\")\n",
+    "    \n",
+    "    # display\n",
+    "    def display_evaluations(self):\n",
+    "        for x in self.metrics_dict:\n",
+    "            print(f\" {x}: {self.metrics_dict[x]}\")\n",
+    "            \n",
+    "        print(f\"\\n Most Common Missed Docs: \\n\")\n",
+    "        self.display_dict(self.most_common_missed_docs)\n",
+    "        print(f\"\\n Most Common Missed Entities: \\n\")\n",
+    "        self.display_dict(self.most_common_missed_entities)\n",
+    "        print(f\"\\n Most Common Entities:\\n\")    \n",
+    "        self.display_dict(self.most_common_entities)\n",
+    "        print(f\"\\n Entity Miss rates:\\n\") \n",
+    "        self.display_dict(self.missed_rates)\n",
+    "                  \n",
+    "                  \n",
+    "                  \n",
+    "    # Driver of the class            \n",
+    "    def evaluate(self):\n",
+    "        # True positives = # text_matches\n",
+    "        # False Negatives = # missed\n",
+    "        # False Positive = sporadic\n",
+    "        # True Negative = N/A from results [need all of original text, or at least word count]\n",
+    "        \n",
+    "        self.initialize(df)\n",
+    "        \n",
+    "        #print(self.missed_entity_dict)\n",
+    "        \n",
+    "        #process rows and create base metrics dictionaries\n",
+    "        for row in df.iterrows():\n",
+    "            if self.is_spurious(row):\n",
+    "                self.metrics_dict['spurious']+=1\n",
+    "            self.process_row(row)\n",
+    "        # perform composite calculatons from base metrics\n",
+    "        self.initialize_most_common(df)\n",
+    "        \n",
+    "        self.calculate_recall()\n",
+    "        self.calculate_recall_w_partial_matches()\n",
+    "        self.calculate_false_discovery_rate()\n",
+    "        self.calculate_missed_rates(self.most_common_missed_entities)\n",
+    "        self.calculate_jaccard_index()\n",
+    "        \n",
+    "        # display calculations\n",
+    "        self.display_evaluations()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 254,
+   "id": "a40e82b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "evaluator= NER_Model_Evaluator(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7997ddf3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 255,
+   "id": "09f8640d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " text_matches: 5369\n",
+      " records: 0\n",
+      " partial_text: 470\n",
+      " label_matches: 5821\n",
+      " actNpred_text: 266\n",
+      " predNact_text: 136\n",
+      " partial_span: 0\n",
+      " missed: 1121\n",
+      " overlaps: 0\n",
+      " spurious: 63\n",
+      " spur_punc: 0\n",
+      " exact_match: 5367\n",
+      " text_no_label: 2\n",
+      " pred_overlaps: 0\n",
+      " no_pred: 0\n",
+      " recall: 0.8272727272727273\n",
+      " partial_recall: 0.8634822804314329\n",
+      " false_discovery_rate: 0.011597938144329897\n",
+      " jacaard: 0.8193193956966275\n",
+      "\n",
+      " Most Common Missed Docs: \n",
+      "\n",
+      " SORN 04-16936.pdf_0 : 34\n",
+      " SORN 04-2542.pdf_1 : 17\n",
+      " Title 1.pdf_11 : 17\n",
+      " PAM 638-8.pdf_26 : 16\n",
+      " MARINE AND HELICOPTERS 1962-1973.pdf_104 : 14\n",
+      " USAR PAM 600-2.pdf_17 : 12\n",
+      " NAVMED P-117 MANMED CHANGE 142.pdf_4 : 12\n",
+      " AJP 4.pdf_18 : 12\n",
+      " CJCSM 3320.02D.pdf_32 : 11\n",
+      " PAM 738-751.pdf_66 : 11\n",
+      "\n",
+      " Most Common Missed Entities: \n",
+      "\n",
+      " Army : 105\n",
+      " NATO : 67\n",
+      " Air Force : 65\n",
+      " DA : 60\n",
+      " Marine Corps : 55\n",
+      " Navy : 44\n",
+      " DoD : 42\n",
+      " United States : 40\n",
+      " Office : 39\n",
+      " USARC : 28\n",
+      "\n",
+      " Most Common Entities:\n",
+      "\n",
+      " DoD : 473\n",
+      " Air Force : 451\n",
+      " Marine Corps : 321\n",
+      " United States : 319\n",
+      " Army : 306\n",
+      " NATO : 297\n",
+      " Navy : 242\n",
+      " Office : 201\n",
+      " DA : 176\n",
+      " AF : 174\n",
+      "\n",
+      " Entity Miss rates:\n",
+      "\n",
+      " Army : 0.3431372549019608\n",
+      " NATO : 0.2255892255892256\n",
+      " Air Force : 0.14412416851441243\n",
+      " DA : 0.3409090909090909\n",
+      " Marine Corps : 0.17133956386292834\n",
+      " Navy : 0.18181818181818182\n",
+      " DoD : 0.08879492600422834\n",
+      " United States : 0.12539184952978055\n",
+      " Office : 0.19402985074626866\n",
+      " USARC : 0.4117647058823529\n"
+     ]
+    }
+   ],
+   "source": [
+    "evaluator.evaluate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 256,
+   "id": "d6f79267",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "most_common_entities=evaluator.most_common_entities\n",
+    "most_common_missed_entities=evaluator.most_common_missed_entities\n",
+    "most_common_missed_docs=evaluator.most_common_missed_docs\n",
+    "entity_dict=evaluator.entity_dict\n",
+    "filenames_set=evaluator.filenames_set\n",
+    "metrics_dict=evaluator.metrics_dict\n",
+    "missed_entity_dict=evaluator.missed_entity_dict\n",
+    "missed_doc_dict=evaluator.missed_doc_dict\n",
+    "missed_rates=evaluator.missed_rates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 279,
+   "id": "eba34507",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dictionaries={'most common entities':most_common_entities,'most common missed entites': most_common_missed_entities, 'most common missed docs': most_common_missed_docs, 'missed rates': missed_rates}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 288,
+   "id": "2a54c636",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for index, x in enumerate(dictionaries):\n",
+    "    my_dict=dictionaries[x]\n",
+    "    plt.figure(index)\n",
+    "    keys = list(my_dict.keys())\n",
+    "    # get values in the same order as keys, and parse percentage values\n",
+    "    vals = [float(my_dict[k]) for k in keys]\n",
+    "    ax = sns.barplot(x=keys, y=vals)\n",
+    "    ax.set_xticklabels(ax.get_xticklabels(),rotation = 75)\n",
+    "    ax.set(title=x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24b90e88",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c96d2212",
+   "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}