task6_recipe_ner.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Определение именованных сущностей в рецептах"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [1] https://open.blogs.nytimes.com/2015/04/09/extracting-structured-data-from-recipes-using-conditional-random-fields\n",
    "* [2] https://open.blogs.nytimes.com/2016/04/27/structured-ingredients-data-tagging\n",
    "* [3] https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html#sphx-glr-beginner-nlp-sequence-models-tutorial-py\n",
    "* [4] https://pytorch.org/tutorials/beginner/saving_loading_models.html\n",
    "* [5] https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)\n",
    "* [6] https://en.wikipedia.org/wiki/Named-entity_recognition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если Вы запускаете ноутбук на colab или kaggle,\n",
    "# выполните следующие строчки, чтобы подгрузить библиотеку dlnlputils:\n",
    "\n",
    "# !git clone https://github.com/Samsung-IT-Academy/stepik-dl-nlp.git && pip install -r stepik-dl-nlp/requirements.txt\n",
    "# import sys; sys.path.append('./stepik-dl-nlp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Для выполнения этого задания не забудьте установить:\n",
    "# !pip3 install spacy_udpipe\n",
    "# !pip3 install ipymarkup\n",
    "# !pip3 install livelossplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если Вы запускаете ноутбук на colab или kaggle, добавьте в начало пути ./stepik-dl-nlp\n",
    "df = pd.read_csv('datasets/nyt-ingredients-head.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Аннотированные (BIO) рецепты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "torch.manual_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если Вы запускаете ноутбук на colab или kaggle, добавьте в начало пути ./stepik-dl-nlp\n",
    "datafile = 'datasets/BIO_recipe_dataset.txt'\n",
    "lines    = open(datafile, encoding='utf-8').read().strip().split('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### словарь и тэги:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dlnlputils.recipe_utils import form_vocabulary_and_tagset, prepare_data, show_markup, Converter, tag_statistics, plot_confusion_matrix, recipe_statistics, plot_recipe_statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocabulary,labels = form_vocabulary_and_tagset(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### рецепты:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recipes_w_tags = prepare_data(lines)\n",
    "\n",
    "len(recipes_w_tags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recipe, test_tags = recipes_w_tags[0]\n",
    "show_markup(test_recipe, test_tags)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### перевод слов и тэгов в индексы - и обратно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "converter = Converter(vocabulary,labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recipe, test_tags = recipes_w_tags[0]\n",
    "\n",
    "\n",
    "encoded_recipe = converter.words_to_index(test_recipe)\n",
    "encoded_tags   = converter.tags_to_index(test_tags)\n",
    "\n",
    "print(encoded_recipe)\n",
    "print(encoded_tags)\n",
    "print()\n",
    "\n",
    "\n",
    "decoded_recipe = converter.indices_to_words(encoded_recipe)\n",
    "decoded_tags   = converter.indices_to_tags(encoded_tags)\n",
    "\n",
    "show_markup(decoded_recipe, decoded_tags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_data = recipes_w_tags[     :40000]\n",
    "test_data     = recipes_w_tags[40000:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EMBEDDING_DIM = 32\n",
    "HIDDEN_DIM    = 32\n",
    "VOCAB_SIZE    = len(converter.word_to_idx)\n",
    "TAGSET_SIZE   = len(converter.tag_to_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTMTagger(nn.Module):\n",
    "\n",
    "    def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):\n",
    "        \n",
    "        super(LSTMTagger, self).__init__()\n",
    "        \n",
    "        self.hidden_dim      = hidden_dim\n",
    "        self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm            = nn.LSTM(embedding_dim, hidden_dim)\n",
    "        self.hidden2tag      = nn.Linear(hidden_dim, tagset_size)\n",
    "\n",
    "    def forward(self, words):\n",
    "        embeds      = self.word_embeddings(words)\n",
    "        lstm_out, _ = self.lstm(embeds.view(len(words), 1, -1))\n",
    "        tag_space   = self.hidden2tag(lstm_out.view(len(words), -1))\n",
    "        tag_scores  = F.log_softmax(tag_space, dim=1)\n",
    "        \n",
    "        return tag_scores\n",
    "    \n",
    "    def predict_tags(self, words):\n",
    "        with torch.no_grad():\n",
    "            tags_pred = model(words).numpy()\n",
    "            tags_pred = np.argmax(tags_pred, axis=1)\n",
    "            \n",
    "        return tags_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model         = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, VOCAB_SIZE, TAGSET_SIZE)\n",
    "loss_function = nn.NLLLoss() \n",
    "optimizer     = optim.SGD(model.parameters(), lr=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from livelossplot import PlotLosses\n",
    "\n",
    "liveplot = PlotLosses()\n",
    "\n",
    "for epoch in range(1): \n",
    "    for i, (recipe, tags) in enumerate(training_data):\n",
    "        \n",
    "        model.zero_grad()\n",
    "        \n",
    "        encoded_recipe = converter.words_to_index(recipe) # слово -> его номер в словаре \n",
    "        encoded_tags   = converter.tags_to_index(tags)    # тэг   -> его номер в списке тэгов\n",
    "        \n",
    "        tag_scores     = model(encoded_recipe)\n",
    "\n",
    "        loss = loss_function(tag_scores, encoded_tags)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        \n",
    "        if i % 500 == 0:\n",
    "            liveplot.update({'negative log likelihood loss': loss})\n",
    "            liveplot.draw()\n",
    "            \n",
    "            \n",
    "        if i == 15000:\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_tags(model, converter, recipe):\n",
    "    \n",
    "    encoded_recipe = converter.words_to_index(recipe)        # слово -> его номер в словаре\n",
    "    \n",
    "    encoded_tags   = model.predict_tags(encoded_recipe)      # предсказанные тэги (номера)\n",
    "\n",
    "    decoded_tags   = converter.indices_to_tags(encoded_tags) # номер тэга -> тэг\n",
    "    \n",
    "    return decoded_tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "\n",
    "    recipe, tags = test_data[np.random.randint(0,7000)]\n",
    "    \n",
    "    tags_pred    = predict_tags(model, converter, recipe)\n",
    "\n",
    "    print('истинные тэги:')\n",
    "    show_markup(recipe, tags)\n",
    "\n",
    "    print('предсказанные тэги:')\n",
    "    show_markup(recipe, tags_pred)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save & Load model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "torch.save(model.state_dict(), 'models/recipe.pt')\n",
    "model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, VOCAB_SIZE, TAGSET_SIZE)\n",
    "\n",
    "model.load_state_dict(torch.load('models/recipe.pt'))\n",
    "model.eval()\n",
    "\n",
    "\n",
    "recipe, tags = test_data[4444]\n",
    "\n",
    "tags_pred = predict_tags(model, recipe)\n",
    "\n",
    "print('ground truth:')\n",
    "print(list(zip(recipe, tags)))\n",
    "print()\n",
    "\n",
    "print('prediction:')\n",
    "print(list(zip(recipe, tags_pred)))   \n",
    "\n",
    "\n",
    "print('ground truth:')\n",
    "show_markup(recipe, tags)\n",
    "\n",
    "print('prediction:')\n",
    "show_markup(recipe, tags_pred)\n",
    "'''\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Проверка возможностей нейросети на тестовых данных:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Количество верно предсказанных тэгов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_correct, total_tags = tag_statistics(model, converter, test_data)\n",
    "\n",
    "\n",
    "print('Статистика верно предсказанных тэгов:\\n')\n",
    "\n",
    "for tag in total_tags.keys():\n",
    "    print('для {}:'.format(tag))\n",
    "    print('  корректно:\\t', total_correct[tag])\n",
    "    print('      всего:\\t',   total_tags[tag])\n",
    "    print('% корректно:\\t', 100 * (total_correct[tag] / float(total_tags[tag])))\n",
    "    print()\n",
    "\n",
    "print('----------')\n",
    "print('в итоге:')\n",
    "print('  корректно:\\t', sum(total_correct.values()))\n",
    "print('      всего:\\t', sum(total_tags.values()))\n",
    "print('% корректно:\\t', 100 * (sum(total_correct.values()) / sum(total_tags.values())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Матрица Ошибок (Confusion Matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = []\n",
    "y_true = []\n",
    "\n",
    "for recipe, tags in test_data:\n",
    "    y_pred += predict_tags(model,converter, recipe)\n",
    "    y_true += tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(y_true, y_pred, classes=list(total_tags.keys()), title='Матрица ошибок')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(y_true, y_pred, classes=list(total_tags.keys()), normalize=True, \n",
    "                      title='Нормализованная матрица ошибок')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Количество верно размеченных рецептов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_recipes, total_recipes = recipe_statistics(model, converter, test_data, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_recipe_statistics(correct_recipes)\n",
    "plot_recipe_statistics(correct_recipes, total_recipes)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}