babelfy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "parameter document:http://babelfy.org/guide"
      ],
      "metadata": {
        "id": "Kb9mxYWVZyFc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import json\n",
        "from collections import defaultdict\n",
        "\n",
        "import pandas as pd\n",
        "\n",
        "from secrets import babelfy_key"
      ],
      "metadata": {
        "id": "r95TZEJ8TzkZ"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib\n",
        "import json \n",
        "\n",
        "# a simple wrapper around Babely's HTTP API\n",
        "def babelfy_request(text, key, lang='ES', annotation_type=\"NAMED_ENTITIES\", matching='EXACT_MATCHING'):\n",
        "    service_url = 'https://babelfy.io/v1/disambiguate'\n",
        "    matching_strategies = ['PARTIAL_MATCHING', 'EXACT_MATCHING']\n",
        "    annotation_types = [\n",
        "        #'ALL',\n",
        "        'NAMED_ENTITIES',\n",
        "        #'CONCEPTS'\n",
        "    ]\n",
        "    \n",
        "    # sanity check on input parameters\n",
        "    assert annotation_type in annotation_types\n",
        "    assert matching in matching_strategies\n",
        "\n",
        "    params = {\n",
        "    'text' : text,\n",
        "    'lang' : lang,\n",
        "    'key'  : key,\n",
        "    'annType': annotation_type,\n",
        "    'match': matching\n",
        "    }\n",
        "\n",
        "    params = urllib.parse.urlencode(params)\n",
        "    params = params.encode('utf8') # POST data must be bytes\n",
        "    req = urllib.request.Request(service_url, data=params, method='POST')\n",
        "    resp = urllib.request.urlopen(req)\n",
        "    data = json.loads(resp.read().decode('utf8'))\n",
        "    return data"
      ],
      "metadata": {
        "id": "6roPTbdMQ1xP"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# print out Babelfy's output in a user friendly way\n",
        "def display_babelfy_output(input_doc, b_output):\n",
        "    \"\"\"Print Babeblfy's output with minimal formatting.\"\"\"\n",
        "    \n",
        "    print(f\"Babelfy found {len(b_output)} links:\")\n",
        "    \n",
        "    for n, entry in enumerate(b_output):\n",
        "        start_offset = entry['charFragment']['start']\n",
        "        end_offset = entry['charFragment']['end'] + 1\n",
        "        surface = input_doc[start_offset:end_offset]\n",
        "        entity_link = entry['DBpediaURL'] if entry['DBpediaURL'] else entry['BabelNetURL']\n",
        "        \n",
        "        print(f\"[{n + 1}] {surface}，({start_offset}, {end_offset}) -> {entity_link}\")\n",
        "    return"
      ],
      "metadata": {
        "id": "QNp7kEijQ9Ng"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "with open(os.path.join('intermediate_data_files', 'plays_with_location_indices.json')) as f:\n",
        "  texts = json.load(f)"
      ],
      "metadata": {
        "id": "kfdk9i5OPJ5Z"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "langs = {'span': 'ES', 'rus': 'RU'}"
      ],
      "metadata": {
        "id": "iaVsuA4RUX0S"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "babelfy_outputs = defaultdict(dict)\n",
        "for lang, plays in texts.items():\n",
        "  for playname, (text, locations) in plays.items():\n",
        "    print(playname)\n",
        "    babelfy_output = babelfy_request(text, babelfy_key, lang=langs[lang])\n",
        "    babelfy_outputs[lang][playname] = babelfy_output"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hQJNSo4nT8g1",
        "outputId": "946ece0d-51fc-4313-b89e-84449b5f8e05"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "galdos-perfecta\n",
            "valle-cara\n",
            "valera-atahualpa\n",
            "echegaray-arrastrarse\n",
            "munoz-ortiz\n",
            "munoz-refugio\n",
            "valle-romance\n",
            "galdos-electra\n",
            "valle-luces\n",
            "galdos-casandra\n",
            "turgenev-holostjak\n",
            "bulgakov-zojkina-kvartira\n",
            "gogol-revizor\n",
            "ostrovsky-beshenye-dengi\n",
            "chekhov-vishnevyi-sad\n",
            "ostrovsky-bespridannitsa\n",
            "chekhov-tri-sestry\n",
            "ostrovsky-groza\n",
            "petrov-ostrov-mira\n",
            "bulgakov-beg\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(os.path.join('intermediate_data_files', 'babelfy_outputs.json'), 'w') as f:\n",
        "  json.dump(babelfy_outputs, f, ensure_ascii=False)"
      ],
      "metadata": {
        "id": "gvqX4MZfXF-h"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rows = []\n",
        "\n",
        "for lang, plays in texts.items():\n",
        "  tp = 0\n",
        "  gs = 0\n",
        "\n",
        "  for playname, (text, locations) in plays.items():\n",
        "    location_spans = {tuple(x[1]): x[2] for x in locations}\n",
        "    gs += len(location_spans)\n",
        "\n",
        "    babelfy_output = babelfy_outputs[lang][playname]\n",
        "    babelfy_output = [x for x in babelfy_output if x['DBpediaURL']]\n",
        "\n",
        "    for output in babelfy_output:\n",
        "      row = {\n",
        "          'lang': lang,\n",
        "          'play': playname\n",
        "      }\n",
        "      st = output['charFragment']['start']\n",
        "      end = output['charFragment']['end'] + 1\n",
        "      row['left'] = text[max(0, st-200):st]\n",
        "      row['loc_text'] = text[st:end]\n",
        "      row['right'] = text[end:min(len(text), end+200)]\n",
        "      row['dblink'] = output['DBpediaURL']\n",
        "  \n",
        "      if (st, end) in location_spans:\n",
        "        tp += 1\n",
        "        row['is_correct_location'] = 1\n",
        "        row['is_correct_link'] = ''\n",
        "        row['is_predicted_as_location'] = 'null'\n",
        "        row['wikilink'] = location_spans[(st, end)]\n",
        "      else:\n",
        "        row['is_correct_location'] = 0\n",
        "        row['is_correct_link'] = 'null'\n",
        "        row['is_predicted_as_location'] = ''\n",
        "        row['wikilink'] = ''\n",
        "\n",
        "      rows.append(row)\n",
        "    \n",
        "  fn = gs - tp\n",
        "  print(f'{lang}: GS {gs}, TP {tp}, FN {fn}')\n",
        "\n",
        "\n",
        "df = pd.DataFrame(rows)\n",
        "df.to_csv('babelfy_output.csv', index=False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B-c1x5_HXA0N",
        "outputId": "9d9ea077-5984-47f1-dd94-e93efe63ff1f"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "span: GS 393, TP 50, FN 343\n",
            "rus: GS 694, TP 26, FN 668\n"
          ]
        }
      ]
    }
  ]
}