math_ds_train.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Dataset Training sample\n",
    "\n",
    "> You can contact me on twitter as [@mandubian](http://twitter.com/mandubian)\n",
    "\n",
    "This notebook demonstrates a Pytorch training of a Multi-Head Self-Attention Transformer model on Mathematical Reasoning Dataset v1.0 as explained in this very cool paper:\n",
    "\n",
    "> Analysing Mathematical Reasoning Abilities of Neural Models\n",
    ">\n",
    "> David Saxton, Edward Grefenstette, Felix Hill, Pushmeet Kohli\n",
    ">\n",
    "> (Submitted on 2 Apr 2019)\n",
    ">\n",
    ">http://arxiv.org/abs/1904.01557\n",
    "\n",
    "**On top of paper, the current project provides a few Numpy/Pytorch helpers to manipulate Mathematical Reasoning Dataset in a simpler way and train very fast different kinds of models on it. Without loading everything in memory, it tries to manage data in a streamed and lazy-loading way (as much as Python allows it).**\n",
    "\n",
    "The idea of the paper is to provide a robust toolkit (https://github.com/deepmind/mathematics_dataset) to randomly and heterogenously generate mathematical datasets among multiple math problem categories:\n",
    "    - algebra\n",
    "    - numbers\n",
    "    - polynomials\n",
    "    - arithmetic\n",
    "    - measurement\n",
    "    - comparison\n",
    "    - probability\n",
    "    - calculus\n",
    "    \n",
    "All problem are constituted of a textual question like `what is 30 + 535?` (max 160 chars) and a textual response `565` (max 30 chars). So it's not an abstract representation of math problem but a very human one and it mixes Natural Language Processing with math concepts.\n",
    "\n",
    "For each of those categories, it provides multiple operation modules. For ex, in `algebra` category:\n",
    "    - mul\n",
    "    - add_or_sub_in_base\n",
    "    - simplify_surd\n",
    "    - mul_div_multiple\n",
    "    - mixed\n",
    "    - nearest_integer_root\n",
    "    - div\n",
    "    - add_or_sub\n",
    "    - add_sub_multiple\n",
    "    - add_sub_multiple_longer\n",
    "    - mul_div_multiple_longer\n",
    "    - div_big\n",
    "    - mul_big\n",
    "    - mixed_longer\n",
    "    - add_or_sub_big\n",
    "\n",
    "Problem can be generated with different difficulties:\n",
    "    - train-easy\n",
    "    - train-medium\n",
    "    - train-hard\n",
    "\n",
    "It also provides test datasets for `interpolation` tests mixing all kinds of problem per category and `extrapolation` tests to measure generalization capabilities of models.\n",
    "\n",
    ">An implementation of dataset generator is provided at >https://github.com/deepmind/mathematics_dataset and a v1.0 of the dataset is >available there\n",
    "\n",
    "\n",
    "The main purpose of this dataset generator is to provide a playground to people who want to study how neural networks can learn to solve mathematical problems or even better learn math abstractions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install --user tensorboardX\n",
    "#!pip install --user --force https://github.com/chengs/tqdm/archive/colab.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "0m8YROdDpRAk",
    "outputId": "e6bb48eb-1c2b-4a99-9558-be452345ba23"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Torch Version 1.0.0.dev20190402\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch.utils import data\n",
    "import torch.optim as optim\n",
    "\n",
    "import math_dataset\n",
    "from math_dataset import MathDatasetManager\n",
    "\n",
    "from transformer.Models import Transformer\n",
    "from math_dataset import (\n",
    "    random_split_dataset,\n",
    "    question_answer_to_position_batch_collate_fn\n",
    ")\n",
    "import model_process\n",
    "import utils\n",
    "from tensorboard_utils import Tensorboard\n",
    "from tensorboard_utils import tensorboard_event_accumulator\n",
    "\n",
    "import checkpoints\n",
    "\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook  \n",
    "\n",
    "print(\"Torch Version\", torch.__version__)\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math Dataset Manager\n",
    "\n",
    "This class is just a Numpy/Pytorch helper to manage all files in Math Dataset v1.0 and select different parts of it by categories or modules to generate a Pytorch dataset for training. Pytorch Datasets created doesn't mount all questions/answers in memory and use Pandas limited streaming features to bufferize data. It allows loading huge files quite fast while keeping memory print reasonable. It also caches lazy datasets and allows fast re-using previously created ones.\n",
    "\n",
    "Here are the main features provided right now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize Math Dataset Manager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initialized MultiFilesMathDataset with categories ['algebra', 'numbers', 'polynomials', 'arithmetic', 'measurement', 'comparison', 'probability', 'calculus'] and types ['train-easy', 'train-medium', 'train-hard', 'interpolate', 'extrapolate']\n"
     ]
    }
   ],
   "source": [
    "mdsmgr = MathDatasetManager(\n",
    "  \"/home/mandubian/datasets/mathematics_dataset/v1.0\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check availables types (difficulties + interpolate + extrapolate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "types ['train-easy', 'train-medium', 'train-hard', 'interpolate', 'extrapolate']\n"
     ]
    }
   ],
   "source": [
    "print(\"types\", list(mdsmgr.get_types()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check availables problem categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "categories ['algebra', 'numbers', 'polynomials', 'arithmetic', 'measurement', 'comparison', 'probability', 'calculus']\n"
     ]
    }
   ],
   "source": [
    "print(\"categories\", list(mdsmgr.get_categories()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check availables modules for a problem category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "modules of arithmetic dict_keys(['mul', 'add_or_sub_in_base', 'simplify_surd', 'mul_div_multiple', 'mixed', 'nearest_integer_root', 'div', 'add_or_sub', 'add_sub_multiple', 'add_sub_multiple_longer', 'mul_div_multiple_longer', 'div_big', 'mul_big', 'mixed_longer', 'add_or_sub_big'])\n"
     ]
    }
   ],
   "source": [
    "print(\"modules of arithmetic\", mdsmgr.get_modules_for_category('arithmetic'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Dataset from a single module in a category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size 666666\n"
     ]
    }
   ],
   "source": [
    "ds = mdsmgr.build_dataset_from_module('arithmetic', 'add_or_sub', 'train-easy')\n",
    "print(\"size\", len(ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Dataset from a single module in a category with limited number of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size 1000\n"
     ]
    }
   ],
   "source": [
    "ds = mdsmgr.build_dataset_from_module('arithmetic', 'add_or_sub', 'train-easy', max_elements=1000)\n",
    "print(\"size\", len(ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Dataset from several modules in a category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size 1333332\n"
     ]
    }
   ],
   "source": [
    "ds = mdsmgr.build_dataset_from_modules('arithmetic', ['add_or_sub', 'add_sub_multiple'], 'train-easy')\n",
    "print(\"size\", len(ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Dataset from all modules in a category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding category arithmetic/../train-easy\n",
      "added module arithmetic/mul/train-easy\n",
      "added module arithmetic/add_or_sub_in_base/train-easy\n",
      "added module arithmetic/simplify_surd/train-easy\n",
      "added module arithmetic/mul_div_multiple/train-easy\n",
      "added module arithmetic/mixed/train-easy\n",
      "added module arithmetic/nearest_integer_root/train-easy\n",
      "added module arithmetic/div/train-easy\n",
      "added module arithmetic/add_or_sub/train-easy\n",
      "added module arithmetic/add_sub_multiple/train-easy\n",
      "size 5999994\n"
     ]
    }
   ],
   "source": [
    "ds = mdsmgr.build_dataset_from_category('arithmetic', 'train-easy')\n",
    "print(\"size\", len(ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Dataset from all modules in several categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding category arithmetic/../train-easy\n",
      "added module arithmetic/mul/train-easy\n",
      "added module arithmetic/add_or_sub_in_base/train-easy\n",
      "added module arithmetic/simplify_surd/train-easy\n",
      "added module arithmetic/mul_div_multiple/train-easy\n",
      "added module arithmetic/mixed/train-easy\n",
      "added module arithmetic/nearest_integer_root/train-easy\n",
      "added module arithmetic/div/train-easy\n",
      "added module arithmetic/add_or_sub/train-easy\n",
      "added module arithmetic/add_sub_multiple/train-easy\n",
      "adding category polynomials/../train-easy\n",
      "added module polynomials/add/train-easy\n",
      "added module polynomials/coefficient_named/train-easy\n",
      "added module polynomials/evaluate_composed/train-easy\n",
      "added module polynomials/compose/train-easy\n",
      "added module polynomials/collect/train-easy\n",
      "added module polynomials/simplify_power/train-easy\n",
      "added module polynomials/evaluate/train-easy\n",
      "added module polynomials/expand/train-easy\n",
      "size 11333322\n"
     ]
    }
   ],
   "source": [
    "ds = mdsmgr.build_dataset_from_categories(['arithmetic', 'polynomials'], 'train-easy')\n",
    "print(\"size\", len(ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pytorch Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device cuda\n"
     ]
    }
   ],
   "source": [
    "seed = 1\n",
    "torch.manual_seed(seed)\n",
    "device = torch.device(\"cuda\")\n",
    "print(\"device\", device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train on Algebra Linear_1d in Easy mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an experiment with a name and a unique ID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_name = \"math_ds_algebra_linear_1d_easy\"\n",
    "unique_id = \"2019-05-25_0900\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Dataset for training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train-easy dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train-easy dataset size 666666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/pandas/core/frame.py:4025: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  return super(DataFrame, self).rename(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "ds = mdsmgr.build_dataset_from_module(\n",
    "    'algebra', 'linear_1d', 'train-easy'\n",
    ")\n",
    "print(\"train-easy dataset size\", len(ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interpolate dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "interpolate dataset size 10000\n"
     ]
    }
   ],
   "source": [
    "ds_interpolate = mdsmgr.build_dataset_from_module(\n",
    "    'algebra', 'linear_1d', 'interpolate'\n",
    ")\n",
    "print(\"interpolate dataset size\", len(ds_interpolate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create default Transformer model\n",
    "\n",
    "Here we test the best model found in the paper: a multi-head self-attention transformer to give a default sample.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = utils.build_transformer()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create basic optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=6e-6, betas=(0.9, 0.995), eps=1e-9)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Pytorch dataloaders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we split data in 90/10% for train/validation and use interpolate for test\n",
    "train_ds, val_ds = math_dataset.random_split_dataset(ds, split_rate=0.9)\n",
    "\n",
    "# we provide the function question_answer_to_position_batch_collate_fn that collates\n",
    "# all questions/answers into transformer format enhanced with char positioning\n",
    "train_loader = data.DataLoader(\n",
    "    train_ds, batch_size=128, shuffle=True, num_workers=4,\n",
    "    collate_fn=question_answer_to_position_batch_collate_fn)\n",
    "\n",
    "val_loader = data.DataLoader(\n",
    "    val_ds, batch_size=128, shuffle=False, num_workers=4,\n",
    "    collate_fn=question_answer_to_position_batch_collate_fn)\n",
    "\n",
    "interpolate_loader = data.DataLoader(\n",
    "    ds_interpolate, batch_size=128, shuffle=False, num_workers=4,\n",
    "    collate_fn=question_answer_to_position_batch_collate_fn)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Tensorboard metrics logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing TensorBoard events locally to runs/math_ds_algebra_linear_1d_easy_2019-05-25_0900\n"
     ]
    }
   ],
   "source": [
    "tb = Tensorboard(exp_name, unique_name=unique_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_process.train(\n",
    "    exp_name, unique_id,\n",
    "    model, \n",
    "    train_loader, val_loader, interpolate_loader,\n",
    "    optimizer, device,\n",
    "    epochs=20, tb=tb, log_interval=100,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Training from Tensorboard data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Restore best model for this experience"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting state from checkpoints/math_ds_algebra_linear_1d_easy_2019-05-25_0900_validation_best.pth\n",
      "Loading model state_dict from state found in checkpoints/math_ds_algebra_linear_1d_easy_2019-05-25_0900_validation_best.pth\n"
     ]
    }
   ],
   "source": [
    "# build default transformer model\n",
    "model = utils.build_transformer()\n",
    "# restore best validation model from checkpoint\n",
    "_ = checkpoints.restore_best_checkpoint(exp_name, unique_id, \"validation\", model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading tensorboard events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_ea = tensorboard_event_accumulator(\n",
    "    \"./runs/math_ds_algebra_linear_1d_easy_2019-05-25_0900_eval/events.out.tfevents.1556176200.c77692173f6a\"\n",
    ")\n",
    "\n",
    "interpolate_ea = tensorboard_event_accumulator(\n",
    "    \"./runs/math_ds_algebra_linear_1d_easy_2019-05-25_0900_interpolate/events.out.tfevents.1556176208.c77692173f6a\"\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_accuracy = valid_ea.Scalars(\"epoch/accuracy\")\n",
    "valid_loss_per_char = valid_ea.Scalars(\"epoch/loss_per_char\")\n",
    "\n",
    "interpolate_accuracy = interpolate_ea.Scalars(\"epoch/accuracy\")\n",
    "interpolate_loss_per_char = interpolate_ea.Scalars(\"epoch/loss_per_char\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot loss per char\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['figure.figsize'] = [10, 6]\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)\n",
    "\n",
    "ax1.plot(\n",
    "    list(map(lambda l: l.step, valid_loss_per_char)),\n",
    "    list(map(lambda l: l.value, valid_loss_per_char)),\n",
    "    marker='+', label='Validation Loss per Char'\n",
    ")\n",
    "ax2.plot(\n",
    "    list(map(lambda l: l.step, interpolate_loss_per_char)),\n",
    "    list(map(lambda l: l.value, interpolate_loss_per_char)),\n",
    "    marker='+', label='Interpolate Loss per Char', color=\"orange\"\n",
    ")\n",
    "plt.title('Algebra/Linear_1d Loss per Char')\n",
    "ax1.legend(loc='upper left', frameon=False)\n",
    "ax2.legend(loc='upper left', frameon=False)\n",
    "plt.xticks(np.arange(0, 20, step=1.0))\n",
    "#plt.yticks(np.arange(0.3, 1.0, step=0.1))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> As we can see, loss per char on validation dataset has a nice optimization curve but for interpolate, it's not the case. It's quite normal, interpolate contains more difficult and general cases. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accuracy Evolution during training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['figure.figsize'] = [10, 6]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(\n",
    "    list(map(lambda l: l.step, valid_accuracy)),\n",
    "    list(map(lambda l: l.value, valid_accuracy)),\n",
    "    marker='+', label='Validation Accuracy'\n",
    ")\n",
    "ax.plot(\n",
    "    list(map(lambda l: l.step, interpolate_accuracy)),\n",
    "    list(map(lambda l: l.value, interpolate_accuracy)),\n",
    "    marker='+', label='Interpolate Accuracy'\n",
    ")\n",
    "plt.title('Algebra/Linear_1d Accuracy')\n",
    "ax.legend(loc='upper left', frameon=False)\n",
    "plt.xticks(np.arange(0, 20, step=1.0))\n",
    "plt.yticks(np.arange(0.3, 1.0, step=0.1))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Accuracy for validation dataset is growing constantly up to 85% while for interpolate dataset, it doesn't change much. Interpolate dataset contains too complicated and generic problems compared to training set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'resp': '2', 'score': -1.52587890625e-05}]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_process.predict_single(\"Solve 17*d - 40 = -3*d for d.\", model, device, n_best=1)\n"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "mathematics_dataset_transformer.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}