scripts/jupyter/dataset-analysis-linking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Annotation analisys (linking)\n",
    "\n",
    "This notebook is an attempt to compute dynamic statistics of the Superconductor dataset links and relationships."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:48:54.024466Z",
     "start_time": "2023-11-10T09:48:53.977415Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "\n",
    "from bs4 import BeautifulSoup, Tag\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%'\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:50:33.125266Z",
     "start_time": "2023-11-10T09:50:33.109900Z"
    }
   },
   "outputs": [],
   "source": [
    "from supermat.supermat_tei_parser import get_sentences_nodes\n",
    "\n",
    "\n",
    "def process_dir(input):\n",
    "    accumulated_statistics = []\n",
    "    abs_start = os.path.abspath(input)\n",
    "    for root, dirs, files in os.walk(input):\n",
    "        for file_ in files:\n",
    "            if not file_.lower().endswith(\".xml\"):\n",
    "                continue\n",
    "            abs_path = os.path.join(root, file_)\n",
    "#             print(\"Processing: \" + str(abs_path))\n",
    "            output_data = process_file(abs_path)\n",
    "            output_data['path'] = os.path.relpath(abs_path, abs_start)\n",
    "            accumulated_statistics.append(output_data)\n",
    "\n",
    "    return accumulated_statistics\n",
    "\n",
    "\n",
    "def get_relationship_name(source_label, destination_label):\n",
    "    relationship_name = \"\"\n",
    "    if str.lower(source_label) == 'tcvalue':\n",
    "        if destination_label == 'material':\n",
    "            relationship_name = 'tcValue-material'\n",
    "        elif destination_label == 'me_method':\n",
    "            relationship_name = 'me_method-tcValue'\n",
    "        else:\n",
    "            raise Exception(\"Something is wrong in the links. \"\n",
    "                        \"The link between \" + source_label + \" and \" + destination_label + \" is invalid. \")\n",
    "    elif str.lower(source_label) == 'pressure':\n",
    "        if str.lower(destination_label) == 'tcvalue':\n",
    "            relationship_name = 'tcValue-pressure'\n",
    "    else:\n",
    "        raise Exception(\"Something is wrong in the links. \"\n",
    "            \"The link between \" + source_label + \" and \" + destination_label + \" is invalid. \")\n",
    "\n",
    "    return relationship_name\n",
    "\n",
    "\n",
    "def process_file(input):\n",
    "#     print (\"Processing file \", input)\n",
    "    with open(input, encoding='utf-8') as fp:\n",
    "        doc = fp.read()\n",
    "\n",
    "    soup = BeautifulSoup(doc, 'xml')\n",
    "\n",
    "    links_statistics = {}\n",
    "    \n",
    "    document_statistics = {\n",
    "        'name': Path(input).name,\n",
    "        'links': links_statistics,\n",
    "        'links_number': 0,\n",
    "        'links_same_paragraph': 0,\n",
    "        'paragraphs': 0,\n",
    "         # In this case we refer to material - tcValue, in particular paragraphs where there are not enough entities for linking\n",
    "        'paragraphs_without_enough_relevant_entities': 0, \n",
    "         # In this case we refer to material - tcValue, having at least 1 material and 1 tcValue\n",
    "        'paragraphs_with_enough_relevant_entities': 0, \n",
    "         # Number of paragraphs with at least one link inside \n",
    "        'paragraphs_with_links_inside' : 0\n",
    "    }\n",
    "\n",
    "    sentences_by_paragraph = get_sentences_nodes(soup, grouped=True)\n",
    "    \n",
    "    dic_dest_relationships = {}\n",
    "    dic_source_relationships = {}\n",
    "    ient = 1\n",
    "    i = 0\n",
    "    for paragraph in sentences_by_paragraph:\n",
    "        for sentence in paragraph:            \n",
    "            paragraphText = ''\n",
    "            paragraph_materials = 0\n",
    "            paragraph_tcValues = 0\n",
    "            document_statistics['paragraphs'] += 1\n",
    "            j = 0\n",
    "            for item in sentence.contents:\n",
    "                if type(item) is Tag:\n",
    "                    if 'type' not in item.attrs:\n",
    "                        raise Exception(\"RS without type is invalid. Stopping\")\n",
    "                    entity_class = item.attrs['type']\n",
    "\n",
    "                    if entity_class == \"material\":\n",
    "                        paragraph_materials += 1\n",
    "                    if entity_class == \"tcValue\":\n",
    "                        paragraph_tcValues += 1\n",
    "\n",
    "                    if len(item.attrs) > 0:\n",
    "                        if 'xml:id' in item.attrs:\n",
    "                            if item.attrs['xml:id'] not in dic_dest_relationships:\n",
    "                                dic_dest_relationships[item.attrs['xml:id']] = [i + 1, j + 1, ient, entity_class]\n",
    "\n",
    "                        if 'corresp' in item.attrs:\n",
    "                            if (i + 1, j + 1) not in dic_source_relationships:\n",
    "                                dic_source_relationships[i + 1, j + 1] = [item.attrs['corresp'].replace('#', ''), ient,\n",
    "                                                                          entity_class]\n",
    "\n",
    "                    j += 1\n",
    "                ient += 1\n",
    "\n",
    "            if paragraph_materials > 0 and paragraph_tcValues > 0:\n",
    "                document_statistics['paragraphs_with_enough_relevant_entities'] += 1\n",
    "            else:\n",
    "                document_statistics['paragraphs_without_enough_relevant_entities'] += 1\n",
    "            i+=1\n",
    "\n",
    "    paragraphs_with_links = []\n",
    "    link_count = 0\n",
    "    for par_num, token_num in dic_source_relationships:\n",
    "        destination_xml_id = dic_source_relationships[par_num, token_num][0]\n",
    "        source_entity_id = dic_source_relationships[par_num, token_num][1]\n",
    "        source_label = dic_source_relationships[par_num, token_num][2]\n",
    "\n",
    "        # destination_xml_id: Use this to pick up information from dic_dest_relationship\n",
    "\n",
    "        for des in destination_xml_id.split(\",\"):\n",
    "            link_count+= 1\n",
    "            destination_item = dic_dest_relationships[str(des)]\n",
    "            destination_paragraph_tsv = destination_item[0]\n",
    "            \n",
    "            ## Same paragraph links\n",
    "            if par_num == destination_paragraph_tsv: \n",
    "                document_statistics['links_same_paragraph'] += 1\n",
    "                paragraphs_with_links.append(par_num)\n",
    "                \n",
    "            # destination_token_tsv = destination_item[1]\n",
    "            # destination_entity_id = destination_item[2]\n",
    "            destination_label = destination_item[3]\n",
    "\n",
    "            relationship_name = get_relationship_name(source_label, destination_label)\n",
    "            if relationship_name not in links_statistics:\n",
    "                links_statistics[relationship_name] = 1\n",
    "            else:\n",
    "                links_statistics[relationship_name] += 1\n",
    "                 \n",
    "#     print(sum([links_statistics[rel] for rel in links_statistics.keys()]))\n",
    "    link_count2 = sum([links_statistics[rel] for rel in links_statistics.keys()])\n",
    "    if link_count != link_count2: \n",
    "        print(link_count, link_count2)\n",
    "    document_statistics['links_number'] = sum([links_statistics[rel] for rel in links_statistics.keys()])\n",
    "    document_statistics['paragraphs_with_links_inside'] = len(set(paragraphs_with_links))\n",
    "    \n",
    "    \n",
    "    ## Cross check \n",
    "    \n",
    "    if document_statistics['paragraphs'] != document_statistics['paragraphs_without_enough_relevant_entities'] + document_statistics['paragraphs_with_enough_relevant_entities']:\n",
    "        print(\"Something is wrong with paragraph count: \\n\\t - paragraph count: \" + str(document_statistics['paragraphs']) + \"\\n\\t - paragraph without enough relevant entities: \" + str(document_statistics['paragraphs_without_enough_relevant_entities']) + \"\\n\\t - paragraph with enough relevant entities: \" + str(document_statistics['paragraphs_with_enough_relevant_entities']))\n",
    "    \n",
    "    return document_statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analysis "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:50:34.268347Z",
     "start_time": "2023-11-10T09:50:34.265958Z"
    }
   },
   "outputs": [],
   "source": [
    "def run_analysis(input):\n",
    "    input_path = Path(input)\n",
    "    documents_statistics = process_dir(input_path)\n",
    "\n",
    "    aggregated_links = {}\n",
    "    links_by_batch = {}\n",
    "    links_same_paragraph = 0\n",
    "    number_of_paragraphs = 0\n",
    "    number_of_paragraphs_with_enough_relevant_entities = 0\n",
    "    number_of_paragraphs_without_enough_relevant_entities = 0\n",
    "    links_count = 0\n",
    "\n",
    "    output_data = {\n",
    "        'path': str(Path(input_path).absolute()),\n",
    "        'files': len(documents_statistics),\n",
    "        'aggregated': aggregated_links,\n",
    "        'batches': links_by_batch\n",
    "    }\n",
    "\n",
    "    ## Summary of all articles\n",
    "\n",
    "    for document_statistics in documents_statistics:\n",
    "#         print(document_statistics)\n",
    "        links_count += document_statistics['links_number']\n",
    "        links_same_paragraph += document_statistics['links_same_paragraph']\n",
    "        number_of_paragraphs += document_statistics['paragraphs']\n",
    "#         print(str(number_of_paragraphs_with_enough_relevant_entities))\n",
    "        number_of_paragraphs_with_enough_relevant_entities += document_statistics['paragraphs_with_enough_relevant_entities']\n",
    "        number_of_paragraphs_without_enough_relevant_entities += document_statistics ['paragraphs_without_enough_relevant_entities']\n",
    "        \n",
    "        for link_name in document_statistics['links']:\n",
    "            link_statistics = document_statistics['links'][link_name]\n",
    "            if link_name not in aggregated_links:\n",
    "                aggregated_links[link_name] = link_statistics\n",
    "            else:\n",
    "                aggregated_links[link_name] += link_statistics\n",
    "\n",
    "    output_data['documents'] = documents_statistics\n",
    "    output_data['paragraphs'] = number_of_paragraphs\n",
    "    output_data['paragraphs_with_enough_relevant_entities'] = number_of_paragraphs_with_enough_relevant_entities\n",
    "    output_data['paragraphs_without_enough_relevant_entities'] = number_of_paragraphs_without_enough_relevant_entities\n",
    "    output_data['links_same_paragraph'] = links_same_paragraph\n",
    "    output_data['links_number'] = links_count\n",
    "\n",
    "\n",
    "    ## Summary by batch (assuming that the batch is the first directory)\n",
    "    for document_statistics in documents_statistics:\n",
    "        batch_name = os.path.dirname(document_statistics['path'])\n",
    "\n",
    "        if batch_name not in links_by_batch:\n",
    "            links_by_batch[batch_name] = {}\n",
    "\n",
    "        for link_name in document_statistics['links']:\n",
    "            link_statistics = document_statistics['links'][link_name]\n",
    "            if link_name not in links_by_batch[batch_name]:\n",
    "                links_by_batch[batch_name][link_name] = link_statistics\n",
    "            else:\n",
    "                links_by_batch[batch_name][link_name] += link_statistics\n",
    "\n",
    "    output_data['batches'] = links_by_batch\n",
    "\n",
    "\n",
    "    return output_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run Analysis "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:50:36.191723Z",
     "start_time": "2023-11-10T09:50:35.348993Z"
    }
   },
   "outputs": [],
   "source": [
    "input = \"../../data/dataset/annotations/xml/final\"\n",
    "    \n",
    "analysed_links = run_analysis(input)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:50:59.869186Z",
     "start_time": "2023-11-10T09:50:59.460710Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "   total paragraphs  paragraphs with insufficient entities  \\\n0             20807                                  20231   \n\n   paragraphs with enough entities  number of links  \\\n0                              576             1524   \n\n   Number of links in the same paragraph  \n0                                    985  ",
      "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>total paragraphs</th>\n      <th>paragraphs with insufficient entities</th>\n      <th>paragraphs with enough entities</th>\n      <th>number of links</th>\n      <th>Number of links in the same paragraph</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>20807</td>\n      <td>20231</td>\n      <td>576</td>\n      <td>1524</td>\n      <td>985</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columns=['total paragraphs', 'paragraphs with insufficient entities', 'paragraphs with enough entities', 'number of links', 'Number of links in the same paragraph']\n",
    "rows = [analysed_links['paragraphs'], analysed_links['paragraphs_without_enough_relevant_entities'], analysed_links['paragraphs_with_enough_relevant_entities'], analysed_links['links_number'], analysed_links['links_same_paragraph']]\n",
    "\n",
    "import pandas as pd\n",
    "pd.DataFrame([rows], columns=columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Summary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:51:07.449886Z",
     "start_time": "2023-11-10T09:51:07.442003Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "{'tcValue-material': 1096, 'tcValue-pressure': 166, 'me_method-tcValue': 262}"
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "analysed_links['aggregated']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Aggregated by link class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:51:08.859662Z",
     "start_time": "2023-11-10T09:51:08.531583Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 400x800 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "aggregated_frequency = analysed_links['aggregated']\n",
    "# analysed_links['batches']\n",
    "\n",
    "labels = []\n",
    "values = []\n",
    "\n",
    "for label in aggregated_frequency.keys(): \n",
    "    labels.append(label)\n",
    "    values.append(aggregated_frequency[label])\n",
    "\n",
    "    \n",
    "## PIE\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def func(pct, allvals):\n",
    "    absolute = int(pct/100.*np.sum(allvals))\n",
    "    return \"{:.1f}%\\n({:d})\".format(pct, absolute)\n",
    "    \n",
    "\n",
    "fig, ax = plt.subplots(figsize=(4, 8), subplot_kw=dict(aspect=\"equal\"))\n",
    "\n",
    "wedges, texts, autotexts = ax.pie(values, autopct=lambda pct: func(pct, values),\n",
    "                                  textprops=dict(color=\"w\"))\n",
    "\n",
    "\n",
    "ax.legend(wedges, labels,\n",
    "          title=\"Labels\",\n",
    "          loc=\"center left\",\n",
    "          bbox_to_anchor=(1, 0, 0.5, 1))\n",
    "\n",
    "plt.setp(autotexts, size=8, weight=\"bold\")\n",
    "ax.set_title(\"Link types\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Aggregation by batch \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2023-11-10T09:51:09.957204Z",
     "start_time": "2023-11-10T09:51:09.881649Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "aggregated_frequency = analysed_links['batches']\n",
    "# aggregated_frequency['batch-1']['me_method-tc'] =  22\n",
    "\n",
    "#'batches': {\n",
    "#  'batch-1': {'material-tc': 120, 'pressure-tc': 17},\n",
    "#  'batch-3': {'material-tc': 57},\n",
    "#  'batch-4': {'material-tc': 102, 'pressure-tc': 2},\n",
    "#  'batch-2': {'material-tc': 34}\n",
    "#}\n",
    "\n",
    "\n",
    "## Compare various batches\n",
    "labels = []\n",
    "values = {}\n",
    "link_names = set()\n",
    "\n",
    "for batch_name in aggregated_frequency.keys():\n",
    "    labels.append(batch_name)\n",
    "    values[batch_name] = []\n",
    "    for label in aggregated_frequency[batch_name].keys():\n",
    "        link_names.add(label)\n",
    "\n",
    "for link_name in link_names:\n",
    "    for batch_name in labels:\n",
    "        if link_name in aggregated_frequency[batch_name]:\n",
    "            values[batch_name].append(aggregated_frequency[batch_name][link_name])\n",
    "        else: \n",
    "            values[batch_name].append(0)\n",
    "            \n",
    "\n",
    "    \n",
    "pass\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for index, link_name in enumerate(link_names):\n",
    "    data_points = []\n",
    "    for batch in labels: \n",
    "        data_points.append(values[batch][index])\n",
    "\n",
    "    position = (x - width*len(link_names)/2) + index * width    \n",
    "    rects1 = ax.bar(position, data_points, width, label=link_name)\n",
    "        \n",
    "\n",
    "# rects2 = ax.bar(x + width/2, women_means, width, label='Women')\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Frequency')\n",
    "ax.set_title('Distribution by batch')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "\n",
    "\n",
    "def autolabel(rects):\n",
    "    \"\"\"Attach a text label above each bar in *rects*, displaying its height.\"\"\"\n",
    "    for rect in rects:\n",
    "        height = rect.get_height()\n",
    "        ax.annotate('{}'.format(height),\n",
    "                    xy=(rect.get_x() + rect.get_width() / 2, height),\n",
    "                    xytext=(0, 3),  # 3 points vertical offset\n",
    "                    textcoords=\"offset points\",\n",
    "                    ha='center', va='bottom')\n",
    "\n",
    "\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}