math_ds_dgl_transformer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install --user dgl\n",
    "!pip install --user --force https://github.com/chengs/tqdm/archive/colab.zip\n",
    "!pip install --user tensorboardX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training a Transformer modelled as a Graph Neural Network with [DGL library](www.dgl.org) on Mathematical Dataset\n",
    "\n",
    "> You can contact me on twitter as [@mandubian](http://twitter.com/mandubian)\n",
    "\n",
    "**This notebook demonstrates the concept of a [Transformer](https://arxiv.org/abs/1706.03762) implemented as a Graph Neural Network using the cool [DGL library](www.dgl.org) and trained on Mathematical Reasoning Dataset v1.0 (arithmeric/add_sub/easy).**\n",
    "\n",
    "> All pictures in next paragraphs are just copies from this [DGL tutorial](https://docs.dgl.ai/en/latest/tutorials/models/4_old_wines/7_transformer.html) and [_All you need is attention_ paper](https://arxiv.org/abs/1706.03762) and I advise you to read both.\n",
    "\n",
    "### Reminders on Transformer\n",
    "\n",
    "A Transformer is an auto-regressive sequence-to-sequence model relying on 2 steps:\n",
    "\n",
    "![Transformer Model](media/transformer_figure.png)\n",
    "\n",
    "- A **multi-layer encoder** consisting in:\n",
    "\n",
    "    * Multi-head and position-aware self-attention that extracts an encoding of the sequence weighted by a map of attention (or energy, importance, likelikhood as you prefer) between every element of the sequence contextually to all the other elements in the same sequence (complexity in $n^2$ , $n$ being the size of sequence) (_picture from DGL tutorial_). ![Forward/Backward Self-Attention](media/encoder_attention.png)\n",
    "    * This builds an implicit relational data-storage containing all unique elements and their relations to all other elements encountered in the dataset.\n",
    "    * From this raw storage, patterns with higher semantics are extracted by fully-connected feed-forward layers.\n",
    "    * Both mechanisms together are designed to build a semantic relational embedding of any input sequence.\n",
    "    * All layers are also followed by residual connections to avoid vanishing risks\n",
    "    * FYI, multi-head is just the equivalent to increasing the volume of convolution filters in a CNN. You give it depth to let it discover different relations.\n",
    "\n",
    "\n",
    "- A **multi-layer decoder** consisting in:\n",
    "  \n",
    "    * Multi-head and position-aware self-attention layer that extracts an encoding of the expected output sequence (_except the last element as we want to predict it from previous elements_) weighted by a map of attention between elements of the output sequence and every **previous** other elements in the same sequence. This backward-only dependency is aimed at ensuring the auto-regressive nature of the network and the fact that you predict the next element from its past, not from its future. (_picture from DGL tutorial_) ![Backward Self-Attention](media/decoder_attention.png)\n",
    "    * Then, Multi-head and position-aware attention (_not self_) layer that encodes previously self-attention encoded output sequence (minus last element) weighted by a map of attention built on the above encoder's embedding of the input sequence (_Ouch I know it's not easy to put it in letters, look at Tranformer model above_). It allows to learn/represent the relations between every element in the output sequence with respect to elements in the input sequence. (_picture from DGL tutorial_) ![Backward Self-Attention](media/cross_language.png)\n",
    "    * Then, Fully-connected feed-forward layer extracts patterns and finally predicts the last/next element of the sequence.\n",
    "    * All layers are also followed by residual connections to avoid vanishing risks\n",
    "    \n",
    "> Transformer model has shown very high efficiency in discovering and storing semantic representation in sequences while being able to extract long-range relations (better than LSTM/RNN in all recent papers). Transformer is the cornerstone of models like BERT that beat all previous state of the art in recent language modeling.\n",
    "\n",
    "### From Transformer to Graph Neural Network\n",
    "\n",
    "In this small introduction to Transformer, I've been using the words `element` and `relation` quite often. When one thinks about elements having relations between each others, one immediately thinks about Graph.\n",
    "\n",
    "Recently, beside Transformers, I've been studying the topic of Graph Neural Networks that allow to build deep learning models that are able to learn, classify, clusterize, transform, generate graphs.\n",
    "\n",
    "Graph is certainly the most important data structure that you can find in all our recent systems. All social networks are based on that. Most database schema can be represented with graphs. Images can be seen are graphs. Result of Image segmentation or object detection can be seen as graphs. Any text can be modeled as a graph. Neural networks are themselves graphs, etc...\n",
    "\n",
    "And actually when you look carefully at Transformer and specially the 3 images above (copied from DGL tutorial), you immediately discover a whole graph ![Full_Graph](media/full_graph.png)\n",
    "\n",
    "- the **encoder self-attention** builds a full graph of the relations between every element and every others in the input sequence. Nodes of the graph are elements in the input sequence. Self-attention weights are the values on the edges between all nodes.\n",
    "- the **decoder self-attention** builds a graph of the relations between every element and the previous ones in the output sequence. Nodes of the graph are elements in the output sequence. Self-attention weights are the values on the edges between all nodes.\n",
    "- the **encoder/decoder attention** builds a graph of the relations between every element in the input sequence and every element in output sequence. Nodes of the graph are elements in the input/output sequence. Attention weights are the values on the edges between all nodes.\n",
    "\n",
    "\n",
    "I won't spend more time explaining how graph neural networks work, it's another long topic and everything is very well explained in this very good [GDL tutorial](https://docs.dgl.ai/en/latest/tutorials/models/4_old_wines/7_transformer.html).\n",
    "\n",
    "**Just keep in mind that Transformer can be seen as a special kind of Graph Neural Network that learns attention as the edge of the graph and finally reduces the whole graph in the prediction of the next element in the sequence.**\n",
    "\n",
    "Graph Neural domain is not so young but it's getting more attraction lately due to recent papers, evolutions and GPU power increase. Nobody knows yet the true power of graph neural networks, multiple models have been studied till now. There are several mature libraries:\n",
    "\n",
    "- [DGL library](www.dgl.org)\n",
    "- [Pytorch Geometric](https://github.com/rusty1s/pytorch_geometric)\n",
    "- [Deepmind GraphNets](https://github.com/deepmind/graph_nets).\n",
    "\n",
    "I'm mainly using Pytorch lately so Geometric and DGL were good candidates. `Pytorch Geometric` provides a lot of already implemented models with good doc and seems to aim at optimizing those models with different modelization tricks (Graph Neural Network are not very light-weight apparently :D). _I think I'll give it a try soon._\n",
    "\n",
    "For this Study, I've chosen `DGL` that provides a very idiomatic way to build graphs and very good documentation and tutorials and samples.\n",
    "\n",
    "_I don't have any mind between both libraries as I haven't got enough experience in this domain. If anyone has, don't hesitate to tell me._\n",
    "\n",
    "In the notebook, I train this DGL-Transformer on Mathematical Reasoning Dataset which is the main topic of this github repository and that was presented 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",
    "\n",
    "Have fun and remember, you're not just a graph... or maybe you are ;)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Torch Version 1.0.0.dev20190402\n",
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "\n",
    "#torch.multiprocessing.set_start_method(\"spawn\")\n",
    "\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",
    "    GraphCollate,\n",
    "    MAX_ANSWER_SZ, MAX_QUESTION_SZ\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",
    "from dgl_transformer.dgl_transformer import Transformer\n",
    "from dgl_transformer.dataset.graph import GraphPool\n",
    "import dgl_model_process\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": "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": [
    "## Initializing Experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_name = \"dgl_transformer_arithmetic_add_or_sub_easy\"\n",
    "unique_id = \"2019-05-03_1000\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initializing Math Dataset Manager & Train/Val/Interpolate Datasets\n",
    "\n",
    "Interpolate dataset is a general-purpose dataset provided besides basic datasets in math reasoning datasets. It contains more generic questions/answers to test the generalization capabilities of your network for a given problem after learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train-easy dataset size 666666\n",
      "interpolate dataset size 10000\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",
    "    'arithmetic', 'add_or_sub', 'train-easy'\n",
    ")\n",
    "print(\"train-easy dataset size\", len(ds))\n",
    "\n",
    "ds_interpolate = mdsmgr.build_dataset_from_module(\n",
    "    'arithmetic', 'add_or_sub', 'interpolate'\n",
    ")\n",
    "print(\"interpolate dataset size\", len(ds_interpolate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build Model and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = utils.build_dgl_transformer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": [
    "## Build Dataloaders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start creating graph pool...\n",
      "successfully created graph pool, time: 4.079s\n"
     ]
    }
   ],
   "source": [
    "# Graph Collate allows to build graph batches for data_loader collation from raw math_dataset data\n",
    "graph_collate = GraphCollate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we split data in 80/10% for train/validation and use interpolate for test\n",
    "train_ds, val_ds = math_dataset.random_split_dataset(ds, split_rate=0.8)\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=56, shuffle=True, num_workers=4,\n",
    "    collate_fn=graph_collate(device), pin_memory=True)\n",
    "\n",
    "val_loader = data.DataLoader(\n",
    "    val_ds, batch_size=56, shuffle=False, num_workers=4,\n",
    "    collate_fn=graph_collate(device))\n",
    "\n",
    "interpolate_loader = data.DataLoader(\n",
    "    ds_interpolate, batch_size=48, shuffle=False, num_workers=4,\n",
    "    collate_fn=graph_collate(device))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing TensorBoard events locally to runs/dgl_transformer_arithmetic_add_or_sub_easy_2019-05-03_1000\n"
     ]
    }
   ],
   "source": [
    "tb = Tensorboard(exp_name, unique_name=unique_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dgl_model_process.train(\n",
    "    exp_name, unique_id,\n",
    "    model, \n",
    "    train_loader, val_loader, interpolate_loader,\n",
    "    optimizer, device,\n",
    "    graph_pool=None,\n",
    "    epochs=20, tb=tb, log_interval=100,\n",
    "    start_epoch=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training remarks\n",
    "\n",
    "I trained this DGL-Graph transformer model for 6 epochs as every epochs takes about 1h15-1h30 on my 1080TI compared to classic Transformer that is about 20-30mn per epoch. I stopped it when it reached a quite flat gradient curve that is comparable to original Transformer training. But the training is clearly not yet over-fitting...\n",
    "\n",
    "I've remarkerd that DGL model training runs much slower than original Transformer but it also consumes as much GPU as CPU. Building graphs apparently take lots of resources. In terms of GPU memory, for original Transformer, I could batch by 128 without any risk of going out of GPU memory. For DGL Transformer, I could go up to 56 elements for batches but with 64, I run out of memory as soon as I want to run validation. So DGL Transformer also consumes more GPU memory.\n",
    "\n",
    "Let's also remark than in original Transformer training, I was using a train/validation dataset split of 90%/10% versus 80%/20% for DGL Transformer training. But it shouldn't change results so much due to the easy nature of arithmetic problems we are trying to learn in the current case.\n",
    "\n",
    "Anyway, let's have a look at training curves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract data from Tensorboard logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aggregating 3 runs that were done on same model to improve its performance\n",
    "# and see best training accuracy on plots\n",
    "original_transfo_train_ea_1 = tensorboard_event_accumulator(\n",
    "    f\"./runs/math_ds_arithmetic_add_or_sub_easy_2019-04-22T13:32:24_train/events.out.tfevents.1555939951.c77692173f6a\"\n",
    ")\n",
    "original_transfo_train_ea_2 = tensorboard_event_accumulator(\n",
    "    f\"./runs/math_ds_arithmetic_add_or_sub_easy_2019-04-22T13:32:24_train/events.out.tfevents.1555967354.c77692173f6a\"\n",
    ")\n",
    "original_transfo_train_ea_3 = tensorboard_event_accumulator(\n",
    "    f\"./runs/math_ds_arithmetic_add_or_sub_easy_2019-04-22T13:32:24_train/events.out.tfevents.1555969013.c77692173f6a\"\n",
    ")\n",
    "\n",
    "\n",
    "original_transfo_valid_ea = tensorboard_event_accumulator(\n",
    "    f\"./runs/math_ds_arithmetic_add_or_sub_easy_2019-04-22T13:32:24_eval/events.out.tfevents.1555941107.c77692173f6a\"\n",
    ")\n",
    "\n",
    "original_transfo_interpolate_ea = tensorboard_event_accumulator(\n",
    "    f\"./runs/math_ds_arithmetic_add_or_sub_easy_2019-04-22T13:32:24_interpolate/events.out.tfevents.1555941116.c77692173f6a\"\n",
    ")\n",
    "\n",
    "original_transfo_train_accuracy_1 = original_transfo_train_ea_1.Scalars(\"epoch/accuracy\")\n",
    "original_transfo_train_accuracy_2 = original_transfo_train_ea_2.Scalars(\"epoch/accuracy\")\n",
    "original_transfo_train_accuracy_3 = original_transfo_train_ea_3.Scalars(\"epoch/accuracy\")\n",
    "#original_transfo_train_loss_per_char_1 = original_transfo_train_ea.Scalars(\"epoch/loss_per_char\")\n",
    "\n",
    "original_transfo_valid_accuracy = original_transfo_valid_ea.Scalars(\"epoch/accuracy\")\n",
    "#original_transfo_valid_loss_per_char = original_transfo_valid_ea.Scalars(\"epoch/loss_per_char\")\n",
    "\n",
    "original_transfo_interpolate_accuracy = original_transfo_interpolate_ea.Scalars(\"epoch/accuracy\")\n",
    "#original_transfo_interpolate_loss_per_char = original_transfo_interpolate_ea.Scalars(\"epoch/loss_per_char\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "dgl_transfo_train_ea = tensorboard_event_accumulator(\n",
    "    f\"./runs/{exp_name}_{unique_id}_train/events.out.tfevents.1556872387.edbc806924f6\"\n",
    ")\n",
    "\n",
    "dgl_transfo_valid_ea = tensorboard_event_accumulator(\n",
    "    f\"./runs/{exp_name}_{unique_id}_eval/events.out.tfevents.1556880346.edbc806924f6\"\n",
    ")\n",
    "\n",
    "dgl_transfo_interpolate_ea = tensorboard_event_accumulator(\n",
    "    f\"./runs/{exp_name}_{unique_id}_interpolate/events.out.tfevents.1556880405.edbc806924f6\"\n",
    ")\n",
    "\n",
    "dgl_transfo_train_accuracy = dgl_transfo_train_ea.Scalars(\"epoch/accuracy\")\n",
    "dgl_transfo_train_loss_per_char = dgl_transfo_train_ea.Scalars(\"epoch/loss_per_char\")\n",
    "\n",
    "dgl_transfo_valid_accuracy = dgl_transfo_valid_ea.Scalars(\"epoch/accuracy\")\n",
    "dgl_valid_loss_per_char = dgl_transfo_valid_ea.Scalars(\"epoch/loss_per_char\")\n",
    "\n",
    "dgl_transfo_interpolate_accuracy = dgl_transfo_interpolate_ea.Scalars(\"epoch/accuracy\")\n",
    "dgl_transfo_interpolate_loss_per_char = dgl_transfo_interpolate_ea.Scalars(\"epoch/loss_per_char\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "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",
    "original_transfo_train_step = list(map(lambda l: l.step, original_transfo_train_accuracy_1))\n",
    "original_transfo_train_step.extend(list(map(lambda l: l.step, original_transfo_train_accuracy_2)))\n",
    "original_transfo_train_step.extend(list(map(lambda l: l.step, original_transfo_train_accuracy_3)))\n",
    "\n",
    "original_transfo_train_value = list(map(lambda l: l.value, original_transfo_train_accuracy_1))\n",
    "original_transfo_train_value.extend(list(map(lambda l: l.value, original_transfo_train_accuracy_2)))\n",
    "original_transfo_train_value.extend(list(map(lambda l: l.value, original_transfo_train_accuracy_3)))\n",
    "\n",
    "ax.plot(\n",
    "    original_transfo_train_step,\n",
    "    original_transfo_train_value,\n",
    "    marker='+', label='Original Transfo Train Accuracy'\n",
    ")\n",
    "ax.plot(\n",
    "    list(map(lambda l: l.step, dgl_transfo_train_accuracy)),\n",
    "    list(map(lambda l: l.value, dgl_transfo_train_accuracy)),\n",
    "    marker='o', label='DGL Transfo Train Accuracy'\n",
    ")\n",
    "plt.title('Arithmetic/Easy Train Accuracy')\n",
    "ax.legend(loc='upper left', frameon=False)\n",
    "plt.xticks(np.arange(0, 15, step=1.0))\n",
    "plt.yticks(np.arange(0.3, 1.0, step=0.1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **As we can see here, while training is much slower per epoch, DGL Transformer accuracy rises much faster and a bit higher than original Transformer (97% vs 94%)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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, original_transfo_valid_accuracy)),\n",
    "    list(map(lambda l: l.value, original_transfo_valid_accuracy)),\n",
    "    marker='+', label='Original Transfo Validation Accuracy'\n",
    ")\n",
    "ax.plot(\n",
    "    list(map(lambda l: l.step, dgl_transfo_valid_accuracy)),\n",
    "    list(map(lambda l: l.value, dgl_transfo_valid_accuracy)),\n",
    "    marker='o', label='DGL Transfo Validation Accuracy'\n",
    ")\n",
    "plt.title('Arithmetic/Easy Accuracy')\n",
    "ax.legend(loc='upper left', frameon=False)\n",
    "plt.xticks(np.arange(0, 12, step=1.0))\n",
    "plt.yticks(np.arange(0.3, 1.0, step=0.1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **For validation dataset, we see the same faster and higher rise of accuracy with DGL transformer (97% vs 90%). It's interesting to remark that it rises up to the same level of accuracy as train dataset (>95%) while original transformer tends to be a bit lower in validation dataset (<95%)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAF1CAYAAADbfv+XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XlY1WX+//HnDbiLK67gluICCCgulZpLrqlpm1q5ZNNik2lN0zJlaU4zX2dqpqas5tdiVuOalkuZLbZpm7vmkmhmAiqCC6CAbPfvj8/heEQUVOAAvh7XxSXns77P4Sgv7/s+922stYiIiIhI0fLxdgEiIiIi5ZFCloiIiEgxUMgSERERKQYKWSIiIiLFQCFLREREpBgoZImIiIgUA4UskSJijPmvMeap8+yfZoz5X0nWlOf+J4wxV3jr/pcDY8xsY8yz3q5DREoHhSyR8zDGfG2MOWaMqVTQsdbaCdbav7rO62WMiS3+CvPnqvsuz23W2urW2r2FPP9WY8xcY0xzY4x1BTTPr5HFU3m+tZz1XM5zbJkJORfyvAq4zmxjTJYxplFR1CUiRUchS+QcjDHNgR6ABa4v4FjfEiipJA0GVng8ruUKablfC7xVWHEyxvh5u4YLYYypBtwEJAGjS/jeZeq1EvEGhSyRcxsL/AjMBsZ57nC1HrxmjFlhjDkJ9M5tRXH94vsEaOzR8tPYdWpFY8y7xpgUY8x2Y0wnj2vuM8Y8YozZaow5aYx5yxjTwBjziev4L4wxtT2Ov9IY870x5rgxZosxppdr+99wwuFM171nurZbY0wr1/dVjDH/Msb8boxJMsasMcZUce3zAfoBKwt6gYwxg40xm4wxycaYGGPMNI99lY0x/zPGHHHVuM71fG4xxmzIc50/GWOWFuJ+vYwxscaYh40xh40xB40x41377gFuBx51Pe/lru2NjTGLjTEJxpjfjDGTPK43zRizyFVnMnCHx7YFrtd9ozEmwuOcdq5WqOOun2G+AdwYU9sY85Hrvsdc3wcV8DNqa4z53Bhz1BizyxgzooCX5CbgODCds9+jvsaYJ4wxv7qexwZjTBPXvlCP+8QbY55wbT+jJdDkaZF1vUcfM8ZsBU4aY/yMMY973GOHMeaGPHXcbYzZ6bG/o+t9vjjPcS8ZY/5TwPMVKVustfrSl77y+QL2AH8EooBMoIHHvtk4rQfdcP6zUtm17VnX/l5AbJ7rTQPSgesAX+D/gB899u/DCXUNgEDgMLAR6OC6/pfAVNexgcAR17VyQ9ERoJ5r/9fAXXnub4FWru9fcR0T6KrlaqCSa9+VwA+u75u7zvM7x2vUC2jvqiEciAeGu/bdCywHqrruEQXUACoBR4F2HtfZBNx0jnu4n4vrflk4oaKC6/mnArU9fi7PepzrA2wAngYqAlcAe4EBHj+TTGC469gqHttudt3jz8Bvru8r4LwvnnBdrw+QArTJe3+gLk4Iqgr4A+8DS/J7Xq7H1YAYYDzg5/q5JwIh53mPrgL+ifOeyQKiPPY9AvwMtAEMEOGqyR84CDyM877yB7qe4/Xrhcf7GOc9uhloAlRxbbsFaOx6/UYCJ4FGHvvigM6uGloBzYBGruNquY7zw3m/R53ruepLX2XxSy1ZIvkwxnTH+WWw0Fq7AfgVuC3PYUuttd9Za3OstemFvPQaa+0Ka2028B7OLz5PL1tr4621ccBq4Cdr7SbX9T/E+cULTtfQCte1cqy1nwPrcUJHQc/NB7gTmGytjbPWZltrv7fWnnIdkrerECDR1XKT+9UOwFr7tbX2Z1cNW4F5QE/XOZk4v9Rbue6xwVqb7LrPAtdzwBgTihPmPir45XNfd7q1NtNauwI4gRMk8tMZJ3hOt9ZmWGdM2hvAKI9jfrDWLnE9hzTXtg3W2kXW2kzg3zhh5ErXV3Vghut6X7rqvjXvja21R6y1i621qdbaFOBvHq9NfoYA+6y1b1trs6y1m4DFOEHlLMaYpkBvYK61Nh4ncI31OOQuYIq1dpd1bLHWHnHd55C19l/W2nRrbYq19qfz1JXXS9bamNzXylr7vrX2gOv1WwDsBrp41PBPa+06Vw17rLW/W2sPAt96PLeBQKLr75pIuaGQJZK/ccBn1tpE1+O55OmOwWl1uFCHPL5PBSqbM8e2xHt8n5bP4+qu75sBt3gGH6A7TgtBQQJwQsOv59h/HWeHrABrbS2Pr50AxpiuxpivXF1iScAE1/XBCZGfAvONMQeMMf80xlRw7XsHuM0YY4AxOGH2FIVzxFqb5fE4ldOvS17NcLptPV+nJ3BafnLl93N0b7PW5gCxOK01jYEY17Zcv+O0CJ7BGFPVGPP/XF2yyTihopY59/i9ZkDXPLXeDjQ8x/FjgJ3W2s2ux3NwXtPc17gJ+f+Mz7W9sM54vYwxY40xmz1qDuP0e+B893qH0+PIRuO8X0TKFQ1cFMnDOGOTRgC+xpjcUFQJ5xdkhLV2i2ubPc9lzrevKMQA71lr776I+yfidFu2BLZ47jDGNMQJahsLWcdcYCYwyFqbbox5EdcvWFcr0DPAM8b5EMEKYBfwlrX2R2NMBs64pNs4u5XwYuV93jHAb9ba4As4B5xwALhb/oKAA7n7jDE+HkGrKRCdzzUexmlh62qtPWSMicTpFjXnqfUba22/89TqaSzQ1OM96ofTcngdsNR1vZbAtnzuM4r8ncTp3syVX8Bz122MaYbTMngtTotgtjFmM6efY24N+VkCvGaMCcNpXXv0HMeJlFlqyRI523AgGwgBIl1f7XC678ae5zxP8UBdY0zNYqkQ/gcMNcYMcA1wruwapBzkcf9858RyhYNZwL9dg8J9jTFXGWeaikHASmttYUOiP3DUFbC64BGWjDG9jTHtXS03yTjdfJ4tQO/iBLRMa+2awj/188r7vNcCKa7B2lVczzXMGNO5gOtEGWNudLUyPgicwhkv9xNOy9mjxpgKxvmwwVBgfj7X8MdpfTxujKkDTC2g1o+A1saYMa5rVzDGdM7tmvVkjLkKJ7x04fR7NAwn9Oa+R98E/mqMCTaOcGNMXdd9GhljHjTGVDLG+BtjurrO2QxcZ4yp4wrcDxbwOlXDCV0JrrrGu+rI9SbwZ2NMlKuGVq5ghqsLfJGr5rXW2v0F3EukzFHIEjnbOOBta+1+a+2h3C+cQHC7KcRH1621v+CMT9rr6kZpXNA5F8JaGwMMw+n6SsBpMXiE03+n/wPcbJxPtb2UzyX+jDMoeh3OIPR/uM7NbzwWOEHBc56sP7m2/xGYboxJwRlcvtDjnIY4v0STgZ3AN5zZJfQezi/kopyg9S0gxPWaL3GNfRuCE0J+w2nFexMoKPwuxRnEfQynW+5G1xiwDJxQNch1rVeBsa6fd14v4gykT8QJaHk/rXnGz8g1bqs/TivTAZyu5X/gtKLmNQ5nTODPed6j/wGGuELdv3F+Hp/h/AzewhmsnoLzQYmhrnvsxhnbBc7PZAvOAPfPcMbOnZO1dgfwL+AHnNDYHvjOY//7OGPR5uJ8QGAJUMfjEu+4zlFXoZRLpvD/YRWR8swVHg8BV1hrk0vgflVwPlHW0Vq7u7jvV1jGmYailbW2ROeduhy5Bu//AjQsifecSElTS5aI5KoDPFWCv+zuA9aVpoAlJcc11u1PwHwFLCmvCjXw3RgzEKcZ2hd401o7I8/+ZjhjPOrhdD2MttZ6bUkREblw1trDwGslcS9jzD6cwdHDS+J+UroYZ8LeeJxPZg70cjkixabA7kLXoNVonD78WJwxHLe6+uJzj3kf+Mha+44xpg8w3lo7pvjKFhERESndCtNd2AXYY63d6xr0OR9nwK2nEJzZqAG+yme/iIiIyGWlMCErkDMnn4vl7In3tgA3ur6/AfB3fVRYRERE5LJUVJOR/hlnodM7cGY1jsOZZ+gMxlnA9R6AatWqRbVt27aIbi8iIiJSfDZs2JBora13IecUJmTF4TH7Mc7Mx3GeB1hrD+BqyTLGVMdZ6PV43gtZa18HXgfo1KmTXb9+/YXUKiIiIuIVxpjfL/ScwnQXrgOCjTEtjDEVcSbKW5bnxgGuj+MC/AXnk4YiIiIil60CQ5ZrIdaJOAu97sRZyHW7MWa6MeZ612G9gF3GmGichVf/Vkz1ioiIiJQJXpvxXd2FIiIiUlYYYzZYaztdyDma8V1ERESkGChkiYiIiBQDhSwRERGRYqCQJSIiIlIMFLLyiI2NZdiwYQQHB9OyZUsmT55MRkZGvsceOHCAm2++ucBrXnfddRw/fta0YYUybdo0nn/++TO2/e1vfyMyMpLIyEh8fX3d37/00ksXdY/C2LFjBxEREXTo0IF9+/YV6pygoKACn/esWbM4dOhQEVR4fl988QXDh59/LeKNGzeycuXKi7r+888/T9WqVUlJSbmo80VEpPwpFyHrhc+ji+Q61lpuvPFGhg8fzu7du4mOjubEiRM8+eSTZx2blZVF48aNWbRoUYHXXbFiBbVq1SqSGgGefPJJNm/ezObNm6lSpYr7+0mTJp1VY1H54IMPuPXWW9m0aRPNmzcvsuteTMgqyufl6VJC1rx584iKimLJkiVFXNWZsrPPWkhBRERKqXIRsv6zaneRXOfLL7+kcuXKjB8/HgBfX19eeOEFZs2aRWpqKrNnz+b666+nT58+XHvttezbt4+wsDAAUlNTGTFiBCEhIdxwww107dqV3CkqmjdvTmJiIvv27aNdu3bcfffdhIaG0r9/f9LS0gB444036Ny5MxEREdx0002kpqZe1HMYPXo09913H126dOGJJ57gxx9/5KqrrqJDhw5069aN3bud1+rNN9/k5ptvZsCAAQQHB/OXv/wFcALMmDFjaN++PWFhYbz00kssW7aMmTNn8vLLL9O3b18A/vnPfxIWFkZYWBgvv/zyeWvas2cPYWFh/OEPfyA0NJRBgwaRnp7OggUL2Lx5MyNHjiQyMpKMjAzWrVtHz549iYqKYtCgQcTHxwPQvXt3HnroITp16sTMmTPdzzMqKorWrVvzySefAJCWlsa4ceNo3749HTt25Ntvvz2rnvxek7S0NKZPn86cOXOIjIxk0aJFnDhxgjvuuIMuXbrQoUMHli9fnu/zi46OJisri2nTpjFv3jz39qysLB566CHCwsIIDw/n1VdfBeCnn37iqquuIiIigq5du5Kamsqbb77Jgw8+6D534MCBrFmzhqysLGrVqsWDDz5IeHg4a9euZerUqXTu3JmwsDAmTJhA7jQs0dHR9OnTh4iICDp27Mi+ffu47bbb+Oijj9zXHTlyJB9//PF5f14iIlI0imrtwiL3zPLt7DiQXOjjR/6/Hwo8JqRxDaYODT3n/u3btxMVFXXGtho1atC0aVP27NkDOK0dW7dupU6dOmd0m7366qvUrl2bHTt2sG3bNiIjI/O9x+7du5k3bx5vvPEGI0aMYPHixYwePZobb7yRu+++G4ApU6bw1ltv8cADDxT4nPJz8OBBfvzxR3x8fEhKSmL16tX4+fmxcuVKpkyZwoIFCwDYsmULGzZsoEKFCrRu3ZoHHniAmJgYEhMT+fnnnwE4fvw4tWrVYu3atQQEBPDggw/y008/MWfOHNatW0dWVhZdunShV69etG/f/pw17dq1i3nz5tG+fXtuvPFGlixZwqhRo3j55ZeZOXMmkZGRnDp1ismTJ7Ns2TICAgKYM2cOTz31FK+//jrgtOLkBtfRo0cTExPDunXr2L17N3379mXPnj289NJLVKpUiZ9//pnt27dz3XXXuYNlrnbt2uX7mjz99NNs27aNF198EYBHH32UgQMHMnv2bI4dO0bXrl3p168flStXPuN68+bNY9SoUfTq1Yvx48eTmJhIQEAAr732GgcOHGDLli34+vpy9OhR0tPTGTVqFIsXL6Zjx44kJSVRqVKl8/48k5KSuOaaa9x1tWnThmeeeQZrLbfddhsrV65k0KBB3HrrrUybNo2hQ4eSnp5OTk4Of/jDH3jttdcYMmQIx44dY926dcydO7ewbyUREbkEpTZkFST2WCpxx9Pdj3/67SgAgbUqE1S7arHdt1+/ftSpU+es7WvWrGHy5MkA7paL/LRo0cIdwKKiotxBbdu2bUyZMoXjx49z4sQJBgwYcNE13nLLLfj4OI2Ux48fZ+zYsfz6669nHde3b19q1KgBQNu2bdm/fz/BwcHs2rWLSZMmMXjwYPr375/vc73pppuoUqUKAMOHD2f16tXnDVmtWrVy7/d83p527tzJ9u3b3a1l2dnZBAUFufePHDnyjONHjBiBj48Pbdq0oUmTJuzevZs1a9bwyCOPABAaGkrjxo3dATnX+V4TT5999hmffPIJM2bMACA9PZ39+/fTunXrM46bP38+K1aswNfXl+HDh7No0SImTJjAF198wYMPPoivry8AderUYdOmTTRt2pSOHTsCULNmzfPWAFCxYkVuuOEG9+NVq1bx3HPPkZ6eTmJiIlFRUVx55ZUkJiYydOhQAHcQ7NOnDxMnTuTIkSPMmzePESNGuOsREZHiVWpD1vlanPJq/vjH7Jsx+JLvGRISctYYq+TkZPbv30+rVq3YuHEj1apVu6R7eLZa+Pr6ursL77jjDpYsWUJERASzZ8/m66+/vuh7eNb45JNPMmDAAP74xz+yZ88eBg4ceM5asrKyqFu3Llu3buWTTz7hlVdeYfHixe6WpEuR373ystYSHh7O6tWrC3xeAMaY8z4+l/O9JnnrWbJkCS1btjzntTZt2sTevXvp3bs3AKdOnaJ169ZMmDChULXk8vPzIycnx/04Pf30fyCqVKnifm6pqalMnDiRjRs3EhgYyJQpU844Ni9jDKNHj2bu3Lm88847zJkz54LqEhGRi1cuxmQVlWuvvZbU1FTeffddwGlJefjhh7njjjuoWvX8rWPdunVj4cKFgPNJvNzutsJKSUmhUaNGZGZmFukvwqSkJAIDAwGYPXt2gccnJCRgreWWW25h+vTpbNy48axjevTowYcffkhaWhonTpxg6dKl9OjR46Lq8/f3d38iLyQkhLi4ONauXQtARkYG27dvP+e577//PtZaoqOjiYmJITg4mB49erhfv507d3Lw4EFatWp1xnnnek08awEYMGDAGePNNm3adFYN8+bN49lnn2Xfvn3s27ePAwcO8NtvvxEbG0u/fv3473//6x6sfvToUUJCQti/f7/7dU1OTiY7O5vmzZuzadMmrLXs27ePDRs25Puc09LS8PHxISAggJSUFBYvXgxA7dq1qVevnnvcWHp6untc3/jx43nuueeoVKkSbdq0OefrKSIiRatchKzJ1wYXyXWMMXz44Ye8//77BAcH07p1aypXrszf//73As/94x//SEJCAiEhIUyZMoXQ0NBCdQXl+utf/0rXrl3p1q0bbdu2vZSncYbHHnuMRx55hI4dO1KYdSpjYmK45ppriIyMZPz48fk+9y5dunDrrbfSuXNnrrzySu67777zdhWez/jx47nrrruIjIzEGMOiRYv405/+RHh4OB06dOCnn34657mBgYF06tSJoUOH8vrrr1OxYkUeeOAB0tLSaN++PbfffjvvvvsuFStWPOO8c70mffr0YcuWLXTo0IFFixYxdepUTp48Sfv27QkNDWXatGlnXMday4IFC87oyjPGMHz4cBYsWMC9995Lw4YNCQ8PJyIigoULF1KpUiXmzZvHfffdR0REBP379+fUqVP07NmTwMBA2rVrx8MPP3zOMX1169Zl3LhxhISEMGjQILp27ereN2fOHP71r38RHh5O9+7dSUhIAKBx48a0bt3a/YEOEREpGVoguohkZ2eTmZlJ5cqV+fXXX+nbty+7du066xe8FI3Ro0dz8803Fzj3leAOilu2bMHf39/b5YiIlEkXs0B0qR2TVdakpqbSu3dvMjMzsdby6quvKmCJ13366afcfffdPPLIIwpYIiIlTC1ZIiIiIgW4mJascjEmS0RERKS0UcgSERERKQYKWSIiIiLFQCFLREREpBgoZOXh6+tLZGQkoaGhRERE8K9//euMmbjXrl1Lr169CA4OpmPHjgwePNg98ei0adN4/vnnz3ntrl27EhkZSdOmTalXrx6RkZFERkbmu8RMUfn3v/9Nu3btGDt2bKGO/+KLLwqcFuHo0aP897//LYryCjR69GiWLFly3mNmzZrFoUOHLur6YWFhjB49+qLOFREROZ+yPYXD1oWwajokxULNILj2aQgfcUmXrFKlCps3bwbg8OHD3HbbbSQnJ/PMM88QHx/PiBEjmDt3LldffTXgrOP366+/FmoyztyJNWfPns369euZOXNmvsdlZ2cX2fpyr776KmvWrKFhw4ZFcj04HbIuZOkYay3WWveaikVp1qxZdOzY8YKf488//4yfnx9fffUVaWlp7rUYi1pWVhZ+fmX7r5qIiFy4stuStXUhLJ8ESTGAdf5cPsnZXkTq16/P66+/zsyZM7HWMnPmTMaNG+cOWADdu3e/5Akxs7KyqFWrFg8++CDh4eGsXbuWqVOn0rlzZ8LCwpgwYYJ7ZvLu3bvz+OOP06VLF9q0acP3338POIGhc+fOREZGEh4ezt69e7nrrrvYv38//fr146WXXiIxMZHrr7+e8PBwrr76arZt23beuqZMmcIf/vAHevbsyRVXXMErr7wCwOOPP86uXbuIjIzk8ccfB2DGjBl06dKF8PBwpk+fDsCePXsICQnh9ttvJzQ0lJiYGGrVqsWkSZMIDQ2lX79+HDlyBICNGzfStWtXwsPDuemmm0hKSjqrnvxekwULFrB582ZGjhxJZGQkGRkZrFu3jp49exIVFcWgQYOIj4/P9/nNmzePsWPH0qdPH/dyNADR0dH06dOHiIgIOnbs6G5p/Pvf/0779u2JiIjgySefdP88ckP5oUOH3Ev4vPnmmwwfPpzevXszYMAAkpOT6dOnDx07diQ8PJyPPvrIfb+3337bPSv8+PHjSUpK4oorrnCv73js2LEzHouISBmR28JQ0l9RUVH2vFY8Zu2s6879Nb2etVNrnP01vd65z1nx2Pnvaa2tVq3aWdtq1qxpDx06ZG+44Qa7ZMmSc547depU+9xzzxV4j7ffftvef//97seZmZkWsIsXL3ZvO3LkiLXW2pycHDtq1Ci7YsUKa6213bp1s48++qi11tqlS5faAQMGWGutnTBhgp0/f7611tr09HSblpZmrbU2MDDQHjt2zH3Ms88+a6219tNPP7X5/Qw+//xzO2zYMGuttU8++aTt3r27PXXqlI2Pj7d16tSxWVlZdvfu3TYiIsJ9zscff2zvu+8+m5OTY7Ozs+2AAQPsd999Z3fv3m2NMXbdunVnPM/cOp966ik7efJka6217dq1s2vWrLHWWvuXv/zFPvzww9Zaa2+//Xb74YcfFviabNq0yf3cr7rqKpuQkGCttfZ///ufvfvuu/P9ObRs2dLGxsbajz/+2A4fPty9vWPHjnbZsmXWWmvT0tLsyZMn7bJly2z37t1tamrqGbV43vvgwYO2ZcuW1lpr33jjDdu0aVN79OhRa621GRkZNikpyVprbXx8vG3VqpW11trNmzfbNm3auK+X++fo0aPt8uXLrbXWvvLKK+6fuYiIeAew3l5g1im7LVnZpy5sezHo2rUr7dq1Y/LkyZd8rYoVK56xBt6qVavo0qULERERfPPNN2cslHzjjTcCEBUV5W5lufrqq3n22Wf55z//SUxMDJUrVz7rHmvWrGHMmDEA9O/fnwMHDnDy5Mnz1jVkyBAqVqxI/fr1qVOnjns9PE+fffYZn3zyCR06dKBjx47s2bOH6OhoAFq2bEmnTqfnbvPz8+OWW24BnPFWa9as4ciRI6Snp9OtWzcAxo0bx7fffnvWfc73muTauXMn27dvp2/fvkRGRjJjxgxiYmLOOu7HH38kMDCQwMBA+vXrx9q1a0lKSuLYsWMkJiYydOhQACpXrkzVqlX54osvuPPOO91dinXq1Dnv6wbOa1y7dm3A+c/M448/Tnh4OP379ycmJobExES+/PJLRo4c6b5e7p933XUXb7/9NuC0dGndQRGRsqf0DhQZNOP8+18Ic3UV5lGzCYz/uMjK2Lt3L76+vtSvX5/Q0FA2btzIsGHDAGeM1aJFi87o+rlYVapUwRgDOEv0TJw4kY0bNxIYGMiUKVNIT093H1upUiXAGaSf24U0ZswYrrrqKj7++GMGDhzIrFmzuOaaay65rtx75b2fJ2utu2vR0549e6hWrdp5r5/7nAtS0GviWUt4eDirV68+7/XmzZvHtm3baN68OQDJycl88MEHF9z16+fn5/5gRN56PJ/7u+++S1JSEhs3bsTPz4+goKB868/Vs2dPJk6cyFdffUWFChWKdNFwEREpGWW3Jevap6FCnoHKFao424tIQkICEyZMYOLEiRhjuP/++5k9e7Z7HBQ4v/yLWlpaGj4+PgQEBJCSksLixYsLPGfv3r20atWKyZMnM2TIELZu3XrWMT169GDOnDmA8ynCwMDAAkNQfvz9/UlJSXE/HjBgAG+99Za7VSw2NpbExMR8z83KyuKDDz4AYO7cuXTv3p26detSpUoV9+v63nvv0bNnzzPOO99r4llPSEgIcXFxrF27FoCMjIyzWrxycnJYtGgRO3bsYN++fezbt48PPviAefPmUbt2berVq+ceo5Wenk5qair9+vVj1qxZpKWlAc7gf4DmzZuzYcMGABYtWnTO1ywpKYn69evj5+fH559/TlxcHAB9+vRhwYIF7uvl/glOS9/tt9+uViwRkTKq9LZkFST3U4RF/OnCtLQ0IiMjyczMxM/PjzFjxvCnP/0JgIYNG7JgwQIee+wx4uLiqF+/PgEBATz99Olg9+yzz/Liiy+6H8fGxl5wDXXr1mXcuHGEhITQqFEjunbtWuA5c+fOZd68eVSoUIHGjRszbdq0s46ZPn06d955J+Hh4VSvXt3dHXWhGjRoQFRUFO3bt2fw4MHMmDGDX375hSuvvBJwQs/cuXPzPbdmzZqsXr2aqVOn0qhRIxYsWAA4weq+++4jLS2NVq1anVXb+V6T8ePHc9ddd1GlShXWrl3LokWLmDRpEsnJyWRnZ/Pwww8TGhrqPv6rr75HvBENAAAgAElEQVSiRYsWNGjQwL2td+/ejB49mvj4eObMmcO9997Lk08+ScWKFVm8eDFDhgxhy5YtdOrUiQoVKjB06FD++te/8sgjjzBy5Ehee+01Bg0adM7XbMyYMQwdOpT27dvTpUsXgoODAYiIiODRRx/lmmuuwc/Pj6ioKN566y0Abr/9dqZPn87IkSMv5McjIiKlhBaIlhKTlZVFQEAAx48f93YpZcL8+fP59NNPLzoMi4hI0bmYBaLLbkuWSDl233338cUXX7By5UpvlyIiIhdJIUtKjJ+fn1qxCum1117zdgkiInKJyu7AdxEREZFSTCFLREREpBgoZImIiIgUA4UsERERkWKgkCUiIiJSDBSyRERERIqBQpaIiIhIMVDIEhERESkGClkiIiIixUAhS0RERKQYKGSJiIiIFAOFLBEREZFiUKiQZYwZaIzZZYzZY4x5PJ/9TY0xXxljNhljthpjriv6UkVERETKjgJDljHGF3gFGASEALcaY0LyHDYFWGit7QCMAl4t6kJFREREypLCtGR1AfZYa/daazOA+cCwPMdYoIbr+5rAgaIrUURERKTs8SvEMYFAjMfjWKBrnmOmAZ8ZYx4AqgF9i6Q6ERERkTKqqAa+3wrMttYGAdcB7xljzrq2MeYeY8x6Y8z6hISEIrq1iIiISOlTmJAVBzTxeBzk2ubpD8BCAGvtD0BlICDvhay1r1trO1lrO9WrV+/iKhYREREpAwoTstYBwcaYFsaYijgD25flOWY/cC2AMaYdTshSU5WIiIhctgoMWdbaLGAi8CmwE+dThNuNMdONMde7DnsYuNsYswWYB9xhrbXFVbSIiJSArQvhhTCYVsv5c+tCb1ckUqYUZuA71toVwIo82572+H4H0K1oSxMREa/ZuhCWT4LMNOdxUozzGCB8hPfqEilDNOO7iIicKTsTPn3ydMDKlZkGq6Z7pyaRMqhQLVkiIlKOZaZD3Hr4/XvYtwZi10Fmav7HJsWWbG0iZZhClojI5SbjJMT85ApV3zkBKzsDMNAgDDqOhZ/fh9QjZ59bM6jEyxUpqxSyRETKu/Qk2P8j/P6dE6oOboacLDC+0CgCut4LzbpB0yuhSm3nnMCoM8dkAVSoAtc+nf89ROQsClkiIuXNySOw39VK9ft3cOhnwIJPBSc8dZsMza6GJl2hkn/+18gd3L5qutNFWDPICVga9C5SaApZIiJlXcqh061Uv38PCTud7X6VIagz9HrcCVVBnZ3WqMIKH6FQJXIJFLJERMqa4/udMJUbrI7+6myvWN1pnQq/xen+a9wB/Cp5t1aRy5hClohIaWYtHN3rBKrcgepJ+519lWtC06uh03inpaphBPjqn3WR0kJ/G0VEShNrIWEX/L7mdKg6ccjZVzXACVNXT3T+rB8KPpruUKS0UsgSEfGmnGyI33Z6jqr9P5yeOsG/ETTvDs27Od1/Aa3BGO/WKyKFppAlIlIcti7M/5N52ZlwcMvp8VT7f4RTSc45tZpB8ABXqLoaardQqBIpwxSyRESKWn7r/i35I6x5AY79Dpknne11gyF0uNNa1exqTfQpUs4oZImIFLVV089e9y8nExJ3Q9QdTktV06vBv4FXyhORkqGQJSJSVE4egS1znZar/ORkweDnS7YmEfEahSwRkUuRkwP7VsOG2fDLR84agL4VXWsB5qHuQJHLikKWiMjFOHEYNs+BDe/Asd+gci3odCd0HOd8WlDr/olc9hSyREQKKycH9n7pBKtdK5zuv2bdoNdfIOT600vWNAhx/tS6fyKXNYUsEZGCJB+ATXNg07vOkjZV6kDXCU6rVb3W+Z+jdf9ELnsKWSIi+cnJht2fw8Z3IHol2Bxo0RP6ToO2Q7QmoIgUSCFLRMTT8RjY9B5s+h8kx0G1+tBtMnQYA3Vbers6ESlDFLJERLIzIfpT5xOCe75wtrXsAwNnQJtB4FvBq+WJSNmkkCUil6+jv8HGd51PCZ6Id9YKvObPTqtV7Wberk5EyjiFLBG5vGRlwK6PnVarvV+D8YHg/s5M7K36ga/+WRSRoqF/TUTk8pC4xxnEvnkupCZCzSbQ6wnoMBpqBnq7OhEphxSyRKT8ykyHncudcLVvNRhfZ4xV1B3OmCsfX29XKCLlmEKWiJQ/h39xgtWWeZB2DGo3dyYDjbwd/Bt6uzoRuUwoZIlI+ZCRCjuWOLOxx/wIPhWg3RBnwtAWPcHHx9sVishlRiFLRMq2Qz87wWrrQjiVBHVaQr+/QsStUL2et6sTkcuYQpaIlD2nTsC2xU6XYNwG8K3krB0YdYezlqAx3q5QREQhS0RKqa0Lz15gOSDYmXrh50WQcQLqtYUB/wcRo6BqHW9XLCJyBoUsESl9ti6E5ZMgM815nBQDH9wDWPCrAqE3OK1WTbqo1UpESi2FLBEpfb545nTAcrNQuRZM3gJVanmlLBGRC6GQJSKlQ0Yq7PkcdiyD5Nj8j0lPUsASkTJDIUtEvOdUirMw885lsPtzyEyFKnWgQjXIPHn28TWDSr5GEZGLpJAlIiUr7ThEr4QdS2HPKsg+BdUbOFMuhAxzPh24/YMzx2QBVKjiDH4XESkjFLJEpPidPOIsyrxjmbMoc04m1AiETnc6Uy806XrmEjfhI5w/8366MHe7iEgZoJAlIsXjxGFn3cCdy+C31WCzoVYzuHICtBsGgVHnn4U9fIRClYiUaQpZIlJ0kg84wWrHUvj9e8A6M7B3m+x0BTaK0JQLInLZUMgSkUtzfL/TDbhjKcSudbbVawc9H3O6AuuHKFiJyGVJIUtELtyRX51QtXMZHNjkbGvYHvpMcboC67X2bn0iIqWAQpaIFM7hX5xQtWMpxG9ztgVGQd9nnBarOld4tz4RkVJGIUtE8metE6ZyuwITdwHG+STggP+DdkOhVhNvVykiUmopZInIadY63X+5XYFH94Lxceau6nI3tB0CNRp5u0oRkTKhUCHLGDMQ+A/gC7xprZ2RZ/8LQG/Xw6pAfWut1r4QKQtyciBuvROsdiyDpP1gfOGKnnD1JCdYVa/n7SpFRMqcAkOWMcYXeAXoB8QC64wxy6y1O3KPsdY+5HH8A0CHYqhVRIpKTjbs/8EJVTuXQ8oB8K0IV/SGXo9Dm0FQtY63qxQRKdMK05LVBdhjrd0LYIyZDwwDdpzj+FuBqUVTnohclK0Lz54tPfRG2LfaabH65SM4mQB+laFVXwh5BloPgMo1vV25iEi5UZiQFQjEeDyOBbrmd6AxphnQAvjyHPvvAe4BaNq06QUVKiKFtHXhmev+JcXAhxNg+YPOossVqkHr/tDuegjuD5Wqe7deEZFyqqgHvo8CFllrs/Pbaa19HXgdoFOnTraI7y0i4LRgeS6sDM6SNlgYOQdaXesstiwiIsXqPAuHucUBnp/TDnJty88oYN6lFiUilyApNv/tmWnQbogClohICSlMyFoHBBtjWhhjKuIEqWV5DzLGtAVqAz8UbYkiUmgnjzgD2PNTM6hkaxERucwVGLKstVnAROBTYCew0Fq73Rgz3Rhzvceho4D51lp1A4p4w6Gf4Y1ekJN1dtCqUMUZ/C4iIiWmUGOyrLUrgBV5tj2d5/G0oitLRC7ItsWw5H6oUhvu+txZWzDvpwvDR3i7ShGRy4pmfBcpy3KynTD13YvQ5EoY8S74N3DWFFSoEhHxKoUskbIq7Rgsvgv2fAGd7oSB/wC/c4zHEhGREqeQJVIWHd4J82+D4zEw5EXoNN7bFYmISB4KWSJlzc6P4MN7oUJVuOMjaHqltysSEZF8KGSJlBU5OfDNP+CbGc6Yq5H/gxqNvV2ViIicg0KWSFmQnuwsjbPrY4i8HQb/GypU9nZVIiJyHgpZIqVd4h5n/NWRPTDon9DlHjDG21WJiEgBFLJESrPoz5xPEPr4wtgl0OIab1ckIiKFVJhldUSkpFkLq/8Nc0dA7aZwz9cKWCIiZYxaskRKm4yTsPR+2P4hhN0M178MFat6uyoREblAClkipcmxfTD/dji8A/pNh6snafyViEgZpZAlUlrs/RrevwNsDtz+PrTq6+2KRETkEmhMloi3WQs/vArv3QjVG8LdXylgiYiUA2rJEvGmzDRY/iBsnQ9th8AN/4VK/t6uSkREioBCloi3JMXCgtFwYBP0ngI9HgYfNS6LiJQXClki3vD797BwLGSmw63zoc0gb1ckIiJFTCFLpCRZC+vfgk8eg9rN4Y4VUK+1t6sSEZFioJAlUlKyTsGKR2DjOxDcH258A6rU8nZVIiJSTBSyREpCyiFYMAZi10KPP0PvJ5ylckREpNxSyBIpbrHrnQlGT6XALe9A6HBvVyQiIiVAIUukOG36H3z0EPg3gjEfQINQb1ckIiIlRCFLpDhkZ8KnT8Da1+GKXnDz21C1jrerEhGREqSQJVLUTibCwnHw+xq4aiL0fQZ89VdNRORyo3/5RYrSgc3OBKMnE5xPD4aP8HZFIiLiJQpZIkVl6/uwbCJUDYA7V0LjDt6uSEREvEghS+RSZWfBqmnw/cvQrJvzCcLq9bxdlYiIeJlClsilSD0Ki+6EvV9B57th4P+BbwVvVyUiIqWAQpbIxYrfDvNvg+QDcP3L0HGstysSEZFSRCFL5GLsWAof3geV/J31B5t09nZFIiJSyihkiVyInBz46m+w+nkI6gwj3oMajbxdlYiIlEIKWSKFlZ4EH9wD0SuhwxgY/C/wq+TtqkREpJRSyBIpjIRoZ/zVsd/guueh811gjLerEhGRUkwhSyQ/WxfCqumQFAtV68KpE1CpOoxdBs27ebs6EREpAxSyRPLauhCWT4LMNOdxaiJg4JpnFLBERKTQfLxdgEips2r66YDlZuGHmV4pR0REyiaFLJG8kmIvbLuIiEg+FLJE8vJvmP/2mkElW4eIiJRpClkinqyFyrXO3l6hClz7dMnXIyIiZZZCloin9bMgYSdE3g41mwDG+XPoSxA+wtvViYhIGaJPF4rkOroXPnsKrugNw17RPFgiInJJ1JIlApCTDUvuBx8/GDZTAUtEpIi98Hm0t0socQpZIgA/vgb7v4dB/9AAdxGRYvCfVbu9XUKJK1TIMsYMNMbsMsbsMcY8fo5jRhhjdhhjthtj5hZtmSLFKGGXMzdWm8EQMcrb1YiIlBvxyeks2hDLg/M3ebsUryhwTJYxxhd4BegHxALrjDHLrLU7PI4JBv4CdLPWHjPG1C+ugkWKVHYWfDgBKlaDoS+qm1BE5BKkZWSzdt9RVkcnsHp3IrviU87Y3/zxjwGYfG0wD/Vr7Y0SS1RhBr53AfZYa/cCGGPmA8OAHR7H3A28Yq09BmCtPVzUhYoUi+9egAMb4ZZ3oLr+byAiciFyciw7DyWzenciq3cnsO63Y2Rk51DR14fOLWpzQ8e29AgOoF3DGlzxxAr2zRjs7ZJLVGFCViAQ4/E4Fuia55jWAMaY7wBfYJq1dmXeCxlj7gHuAWjatOnF1CtSdA5uha//AWE3Q+hwb1cjIlImxCenu0PVmt2JHDmZAUCbBv6MvaoZPVrXo0vzOlSp6OvlSr2vqKZw8AOCgV5AEPCtMaa9tfa450HW2teB1wE6depki+jeIhcu6xQsuQ+q1oHrnvN2NSIipVZaRjY//XaE1bsTWePRBRhQvSI9ggPoEVyP7sEBNKhR+bzXmXxtcEmUW6oUJmTFAU08Hge5tnmKBX6y1mYCvxljonFC17oiqVKkqH3zD4jfBrctdIKWiIgAThfgjoPJrNmTpwvQz4cuzetwQ8dAdxegj0/hx7FeDmOw8ipMyFoHBBtjWuCEq1HAbXmOWQLcCrxtjAnA6T7cW5SFihSZ2PWw5gXoMBpaD/B2NSIiXneuLsC2DdUFeCkKDFnW2ixjzETgU5zxVrOstduNMdOB9dbaZa59/Y0xO4Bs4BFr7ZHiLFzkomSkwof3Qo1AGPB/3q5GRMQrPLsAV+9OIDr+BHDhXYByfoUak2WtXQGsyLPtaY/vLfAn15dI6fXlX+HIHhi7FCrX8HY1IiIlIrcLMDdUrd93ZhfgTR2D6BFcj7YN/S+oC1DOT2sXyuXjt9Xw46vQ5R64ope3qxERKVaHktJZvduZr+q7PWd2AY67uhk9guvRWV2AxUohSy4Pp1Jg6R+hzhXQd5q3qxERKXKpGVn89NtR1uTTBXhN63p0bxWgLsASppAll4fPnoKkWBi/0pndXUSkDHnh8+izPp2nLsDSTyFLyr89X8CGt6HbZGiadx5dEZHS7z+rdvNQv9aF6gLs0qIOlSuoC7A0UMiS8i3tGCx9AOq1hV5PeLsaEZELEp+czpYYZ17v/i98c1YXYI/gALq3CqC+ugBLJYUsKd8+eRxOxMOtc6GC/hESkdIrKTWTrXHH2RqbxJaY43y3J5GTGdnu/bkB67YuTXl2eJi6AMsAhSwpv3Yuh63zoefj0LiDt6sREXFLy8hm+4EktsQmsTXWCVa/JZ50728RUI2+IQ0ID6pFRFBNbv7vD5fd4srlgUKWlE8nE2H5g9AwHK75s7erEZHLWGZ2DtHxKWyJcQLVltgkouNTyM5xlvBtWKMy4UE1uTkqiPCgmoQH1qJm1QperlqKgkKWlD/WwkcPwqlkuGE5+OofKxEpGTk5ln1HTrI1NonNMcfZGnuc7QeSOZWVA0DNKhUID6rJtW1bEh5Uk4gmtQo1pcLluLhyeaCQJeXPz4ucrsK+z0CDEG9XIyLllLWWQ8npHi1UTrdfSnoWAJUr+BDWuCajr2zmBKqgWjSrWxVjLnws1eW4uHJ5oJAl5UvyQVjxMAR1gasf8HY1IlKOHE/NcMZQxRx3j6U6nHIKAD8fQ5uG/gwJb0xkk5qEB9UiuH51/Hx9vFy1eJNClpQf1sLySZCVATf8F3w0T4yIXJzUjCy2xSW7x1BtjT3O70dS3fuvqFeNbq0CiAiqSXiTWoQ0qqG5qeQsCllSfmx6D3Z/BoOeg7otvV2NiJQi+c2YniszO4ddh1LcY6i2ugamu8al07hmZcKDajGycxMig2oRFlSTGpU11lMKppAl5cOx32HlX6B5D+h8l7erEZFSJnfG9Jwcy97Ek04Llavbb8fBZDJcA9NrV61AeFAt+rumTwhvUpP6/ppjTy6OQpaUfTk5sPR+wMCwV8BHYyBEBLJzLPuPpvLLwWQAbnvjR36OTSLllDMwvWpFX8ICazLuqmau+ahq0aROlYsamC6SH4UsKfvWvQH7VsP1L0PtZt6uRkS8ICHlFLsOpfDLoWR2HUphV3wK2w8kkZ1z+pjvfz0CQN929XlkQFta1a+Or2ZNl2KkkCVlW+Ie+HwqBPeHDmO8XY2IFLPUjCyi40+w61AyvxxKcQLVoRT3QsngrOvXpqE/465qQduG/rRp6M+wV77TjOlS4hSypOzKyYYlE8CvEgx9CdTEL1JuZGXnsO9IqitEuQJVfAr7j6ZiXQPSq1TwpXWD6lzbrj5tGtZwB6qA6pW8W7yIi0KWlF3fvwSx6+Cmt6BGI29XIyIXwVrL4ZRTrlap061Tuw+fcA9G9zHQPKAaoY1rcGOHINo09KdtQ3+a1qla6EWSNWO6eINClpRN8dvhq79DyDAIu8nb1YhIIaSkZxIdn+IOUr8cSiE6PoXjqZnuY+r7V3J19TVzt061ql/9kueg0ozp4g0KWVL2ZGfChxOgck0Y/G91E4qUMpnZOexNOHl6ELorUMUdT3MfU62iL60b+jMorCFtGvi7A1XtahW9WLlI0VLIkrLn2+fh0FYYOQeqBXi7GpFy71wTeVprOZCUftYg9F8TTpCZ7Qyc8vUxXBFQjQ5Na3FrlybuMBVYq0qhu/pEyiqFLClbDmyCb5+D8FHQboi3qxG5LPxn1W7u7N7izEHoroHouYshgzMzepuG/vRsU88ZhN6gBi3rV6OSn5abkcuTQpaUHZnpTjdh9QYwaIa3qxEp1w4lpfNN9GG+3pUAQMQzn7n3+Vf2o00Df66PaEzbRk7LVOsG/tSsoqVmRDwpZEnZ8dXfIOEXGL0YqtT2djUi5Upmdg4bfz/G19EJfL0rgZ2uWdLzurNbc54aEqJZ0UUKQSFLyob9P8L3L0PUeGjV19vViJQL8cnpfLMrga+jD7N6dyIp6Vn4+RiimtXm8UFt6dWmHm0a+NPiLys0kafIRVDIktIv46TTTVirKfT/q7erESmzsrJz2Lj/OF/vcroBd7haqxrUqMR1YY3o3bYeV7cKoEZldfuJFAWFLCn9Pp8Kx/bBHR9BJX9vVyNSphxOTufr6AS+2ZXA6t0JJKdn4etqrXp0YBt6t6lP24b+5+3+00SeIhdHIUtKt1+/chaAvvJ+aN7d29WIlHpZ2TlsijndWrX9gNNaVd+/EgPDGtK7TX26BV9Ya5Um8hS5OApZUnqlJ8HSiVA3GK59ytvViJRah1Nyx1YlsDrao7WqaW0eGeC0VrVrdP7WKhEpegpZUnqtfAJSDsAfPocKVbxdjUipkZWdw+aY43ztGrS+Le50a9WA0Ib0blufbq0CNKWCiJcpZEnptGslbP4f9HgYgjp5uxoRr0tIOcU30Ql8vcv5JGBSWia+PoaOTWvxyIA29GpTj5BGNdRaJVKKKGRJ6ZN6FJZPggZh0PMxb1cj4hXZOZbNMcec1qpdCfwclwRAPf9K9AtpQO829eneKoCaVdVaJVJaKWRJ6bPiz07QGr0Y/Cp5uxqREpN44tTpsVW7EziemomPgY5Na/Pn/q3p1aY+IY1qaM0/kTJCIUtKl20fwLbF0GcKNGzv7WpEipXTWnWcb3Yd5uvoBLbGOq1VAdUrcW3bBvRqU48ewQHUqlrRy5WKyMVQyJLSIyUePn4YGneEbg95uxqRIvHC59FnTIGQeOIU37qWrvnWo7WqQ9PaPNzPaa0KbazWKpHyQCFLSgdr4aMHITMVbvh/4Ku3ppQP/1m1m55t6vH1rgS+2XWYrXFJWAsB1SvSp219erWpzzVqrRIpl/SbTEqHLfNg1woY8Heop4kPpWzLybFs2H+MDzfFAXDjq9/jYyCySS0e6tuaXm3qEda4plqrRMo5hSzxvqRY+OQxaNYNut7n7WpELlp0fApLNsXx3g+/k3Iq64x9ORZ6BNdjkpaoEblsKGSJd1nrzOqekw3DXgEfH29XJHJBDiWls2xLHB9uOsDOg8n4+hi6twpgeIfG9A9pSOjUT9k3Y7C3yxQRL1DIEu9aPwv2fgWD/w11Wni7GpFCSUrLZOW2gyzZdIAffzuCtRDRpBZTh4YwJLwx9fw19YiIKGSJNx3dC589BVf0hk53ersakfM6lZXNV78ksHRzHKt+OUxGVg4tAqox+dpghkUG0iKgWr7nTVb3oMhlq1AhyxgzEPgP4Au8aa2dkWf/HcBzQJxr00xr7ZtFWKeUNznZsOR+8PGDYTNBS4FIKZSTY/npt6Ms3RzHip8PkpyeRUD1itzWpSnDOwQSEVSzwGVsPKdvEJHLS4EhyxjjC7wC9ANigXXGmGXW2h15Dl1grZ1YDDVKefTja7D/exj+X6gZ5O1qRM6w82AySzbHsXzzAQ4kpVO1oi8DQxsyrEMg3VrWxc9XYwdFpGCFacnqAuyx1u4FMMbMB4YBeUOWSOEk7IJV06HNYIgY5e1qRACIO57Gss0HWLIpjl3xKfj6GHq2rsdjg9rSL6QBVStqdIWIXJjC/KsRCMR4PI4FuuZz3E3GmGuAaOAha21M3gOMMfcA9wA0bdr0wquVsi87Cz68FypWg6EvqptQvCopNZOPfz7Iks1xrP3tKAAdm9Zi+rBQBrdvRN3qGsAuIhevqP5rthyYZ609ZYy5F3gH6JP3IGvt68DrAJ06dbJFdG8pS9a8AAc2wS3vQPX63q5GLkPpmdl8+cthlmyK46tdh8nMtlxRrxoP92vNsMhAmtat6u0SRaScKEzIigOaeDwO4vQAdwCstUc8Hr4J/PPSS5Ny5+BW+GYGhN0EocO9XY1cRrJzLD/tPcKHm+JYue0QKaeyqOdfibFXNWd4ZCBhgTUKHMAuInKhChOy1gHBxpgWOOFqFHCb5wHGmEbW2oOuh9cDO4u0Sin7sk7BhxOgal247nlvVyOXAWst2w8ks3RzHMu2HCA++RTVK/kxILQhN3QI5KqWdfHVsjYiUowKDFnW2ixjzETgU5wpHGZZa7cbY6YD6621y4BJxpjrgSzgKHBHMdYsZdHXM+Dwdrh1AVSt4+1qpByLOZrKsi0H+HBTHHsOn6CCr6Fn6/o8NaQxfds1oHIFX2+XKCKXCWOtd4ZGderUya5fv94r95YSFrse3uoHkbc5S+eIFLFjJzP46OeDLN0Ux/rfjwHQuXlthkUGMrh9I2pXq+jlCkWkrDPGbLDWdrqQc/SZZCleGanOpwlrBMKA//N2NVKOpGVk88XOeJZsiuOb6ASycizB9avzyIA2XB/RmCZ1NIBdRLxLIUuK3taFzjxYSbHOVA0ZJ2DsUqhcw9uVSRn0wufR7lnTs7Jz+P7XIyzZHMen2w5xMiObhjUqc2f3FgyLbExIIw1gF5HSQyFLitbWhbB8EmSmOY8zTjhL55w47N26pMz6z6rdXNuuPks2HWD51gMkpJzCv5Ifg8MbMbxDIF1baAC7iJROCllStFZNPx2wcuVkOdvDR3inJimTTpzK4n8//g7A9TO/o6KvD73b1mN4ZCC929bXAHYRKfUUsqRoJcVe2HaRPFLSM7n3vQ18/+uR/9/encdXWR/4Hv/8krAvIQTCkhWSQGRHImJRgQRGqlbUutWp4+0sThUUnZl22r56e2eceb2uW7VUEaWAu1K17egde9t6WcIqEhBFZU3IhmDAhCRkPcvv/nGOCAKSk+Tkl3Pyfb9evHKew3PO+T4h8Hx5nt/ze854vsXnJ2f4QL49cYSjZCIioVHJko4VnwI1Z91RSTeBlguqa/Lw/OYSVmw6RE2jhzljh7J47hiuX7qZkoeucehPFuoAABs7SURBVB1PRCRkKlnSsfJ/Af91d+AU4Zd69Ak8L3IOtcFytTJYrvJzkrgvP5vJqYNcRxMRaReVLOlYY+ZDTI/AL29T4AhW/i80HkvOUtPo4bnNh1i16RC1TV7mXjSMxfnZTEyJP2O9xfnZjhKKiLSPSpZ0rPeXg7cR7loPI6e6TiNdUE2Dh5WbD/Hc5kPUNXmZNy5QriYkx59z/S+nbxARiTQqWdJxmutg61OQfZUKlpzlREMLqzYd4rnNJdQ1e7lq/DDuy89m/MhzlysRkUinkiUdZ/tKaKyGWT92nUS6kOr6FlZuOsTzW0o42ezl2xOGc29eNuNGanJaEYluKlnSMVrqYcuTkJkPKSHd2kmiVFV9Cys2FvPClhLqW3xcM3EE9+ZnkTNc5UpEugeVLOkYO56HhuMw619dJxHHqupb+M3GYl7cUkKDx8fVE0dwX142Y4cPcB1NRKRTqWRJ+3kaYfMSGDUL0i51nUYc+eJkM8s3FvPS1lIaPT6unTSS+/KyyB6mciUi3ZNKlrTfzhfh5Odw03Ouk4gDx082s3xDoFw1e318Z/JI7s3LIitJ5UpEujeVLGkfTxNsegLSL4eMma7TSCeqrGtieUExL28rpcXrZ8GUZBblZZE5tL/raCIiXYJKlrTPrpeh7gjc8KzrJNJJKuuaeLagmFeC5er6YLkarXIlInIGlSxpO28LbHwCUmfAqCtdp5Ewq6xtYllBEa9uK8Prt6fK1agh/VxHExHpklSypO0+fBVqK+C6X4MxrtNImBytaeKZgiJefb8Mn99y49RkFs7JIkPlSkTkG6lkSdv4PLDxl5CcC5l5rtNIGBypaeSZ9UW8tr0cv99y48WBcpWeqHIlItIaKlnSNh/9Fk6UwdW/1FGsKPPZiUaWrS/it9vL8VvLTdNSWDgni9TBfV1HExGJKCpZEjqfFzY8BiOmQPY812mkgxw+0cjT6w7yRmEFFstN01K5Z3amypWISBupZEnoPn4Tqg/Bba/pKFYUqKhu4On1RbxRWA7ALbmp3D07k5QElSsRkfZQyZLQ+H2w4VEYNhHGftt1GmmH8qoGnl5/kDd3VGAw3HpJKnfPziJ5UB/X0UREooJKloTmkz/AFwfhlpd0FCtClX3RwNJ1B/ndzgpijOF709O4e3YmI+JVrkREOpJKlrSe3w8Fj0DSOMi51nUaaYUn3t3PA/PGAIFy9dS6A/xu52FiYwx/fWkaP1S5EhEJG5Usab09b8HxfYF7FMbEuE4jrbBkzQFumJrMU+sO8ocPDhMXY7hjRjp3z85k2MDeruOJiEQ1lSxpHb8fCh6FIWNh3ALXaaQVSo7XA5D/eAFxMYY7L8vgh7NGk6RyJSLSKVSypHX2vQOVn8CNKyAm1nUa+Qb/9vbHPL+l9NSyz2/x+S0DesepYImIdCKVLLkwa6HgYUjMggk3uk4j51Fe1cCTawNjrnrFxfD9Gems3HSIkoeucR1NRKRbUsmSC9v/Jzi6G65/RkexuqCK6sDVgm8UVhATHHN1z+xMkgb2ZuWmQ67jiYh0WypZ8s2+PIqVkAETb3adRk5z+ERjsFyVYwhcLXj37CyGx391SnBxfrbDhCIi3ZtKlnyzg/8PPvsArnsKYvXj0hUcqQmUq99uD8zQftsladwz59xTMXw5fYOIiHQ+7TXl/KyF9Q9BfBpMvs11mm7v89omnl53kNfeL8diuTk3lYVzNEO7iEhXpZIl51e8Dg4XwrW/gtgertN0W5W1TTy9vohX3y/D77fcnJvCwjlZuregiEgXp5Il52YtrH8YBqbAlNtdp+mWKuuaeGZ9Ma9sK8Xrt9x0cQqL8rJIHaxyJSISCVSy5NxKNkL5e3D1YxDXy3WabuX4yWaeLSjipfdK8fgsN0xN5t68LNIT+7mOJiIiIVDJknMreAQGjICpd7hO0m18cbKZ5RuKeXFrKc1eH9dPTea+vGwyhqhciYhEIpUsOVvJ5sCRrPkPQw/NEB5u1fUtLN9YzAtbSmjy+Lhu8kjuzc8mc2h/19FERKQdVLLkbBsegX5JMO1O10mi2omGFn6zsZjnN5fQ4PHxnUkjuS8/m6wklSsRkWigkiVnKtsGxevhr/4TemhqgHCoafCwYlMxz20uob7Fy9UTR3B/fjbZwwa4jiYiIh1IJUvOtOER6JsIuX/rOknUqWn0sGrTIVZtOkRds5erJw5ncf4Yxg5XuRIRiUatKlnGmPnAEiAWWGGtfeg8630XeBO4xFpb2GEppXNU7AjM8D7336CnBlt3lNomD89tKmHlpmJqm7zMHz+cxXOzuWjEQNfRREQkjC5YsowxscBSYB5QAWw3xrxtrf30a+sNABYD28IRVDrBhkegTwJc8veuk0SFuiYPL2wp4TcbD1HT6GHeuGHcPzeb8SPjXUcTEZFO0JojWdOBg9baYgBjzGpgAfDp19b7D+Bh4EcdmlA6x2e7YP+fIO/n0Eunr9rjZLM3WK6KOdHgYe5FSdw/dwwTklWuRES6k9aUrGSg/LTlCuDS01cwxlwMpFpr3zHGqGRFog2PQu94mH6X6yQRq77Zy4tbS1m+oYjqBg95OUncPzebSSmDXEcTEREH2j3w3RgTAzwO/I9WrHsXcBdAWlpaez9aOsrR3bD3v2H2TwNFS0LS0OLl5fdKebagmC/qW5g1ZigPzBvDlFSVKxGR7qw1JeswkHrackrwuS8NACYA640xAMOBt40x13198Lu1djmwHCA3N9e2I7d0pA2PQq+BcOk/uk4SURpbfLyyrZRnCoo4frKFK7KHcP/cMUxLT3AdTUREuoDWlKztQLYxZhSBcnUbcOqOwdbaGmDIl8vGmPXAv+jqwgjx+afw6Vtw5Y8Cg97lgpo8Pl7dVsaygiKO1TUzMyuRZ+aOITdjsOtoIiLShVywZFlrvcaYRcCfCUzhsMpa+4kx5kGg0Fr7drhDShhtfAx69ocZ97hO0uU1eXysfr+Mp9cXUVnXzGWjE1l6+8VMH6VyJSIiZ2vVmCxr7R+BP37tuV+cZ93Z7Y8lneLYfvj493D5/dBXReFcnnh3P/fMyeS328t5el0RR2ubmD5qML/+3lRmjE50HU9ERLowzfjenW18LHDrnMsWuU7SJbV4/SxZc4DXC8s5UtPEJRkJPH7LZC7LTCQ4/lBEROS8VLK6qy+KYPcbcNlC6Dfkwut3I00eH68XlvPM+iIARg7qw6M3TWZmlsqViIi0nkpWd7XxlxDbE751n+skXUZDi5dXt5Xx+Lv7aWjxnXp+R2k131+5jcX52Twwb4zDhCIiEklUsrqjqkPw4erAlA39k1ynca62ycNLW0tZuekQVfUtzMxKZNGcbGaMHsyon/6RkoeucR1RREQikEpWd7TpcYiJ6/ZHsU40tLBqcwnPbz5EbZOXOWOHsigvW/NciYhIh1DJ6m5OlMGuVyH3b2HgCNdpnDhW18yKTcW8vLWU+hYf88cPZ1Fe1jnvLbg4P9tBQhERiQYqWd3NpifAxMDM+10n6XRHa5p4dkMRr71fRovXz7WTRrJwThZjh5//htgagyUiIm2lktWd1FTAzpfg4jsgPtl1mk5TXtXAsoIi3iyswG8tN0xN5u7ZmYwe2t91NBERiWIqWd3J5iWAhcsfcJ2kUxQfO8nSdUX8167DxBrDzbkp/HBWJqmD+7qOJiIi3YBKVndRewR2vABTbodBaa7ThNXeo7UsXVfEOx99Rs+4GO68LIO7rhzN8PjerqOJiEg3opLVXWz5Nfi9cPk/uU4SNrsranhy7QH+8unn9OsZy11XZvJ3l49i6IBerqOJiEg3pJLVHZyshMLnYPJtMHiU6zQdbkdpFU+uPcj6fccY2DuOxfnZ/GBmBoP69nQdTUREujGVrO5gy5Pga4Yr/tl1kg5jrWVr8Rc8ueYgW4u/YHC/nvzoqrHccVk6A3v3cB1PREREJSvq1R+H7Stg4s2QmOk6TbtZa1m//xhPrT3IjtJqkgb04ufXXMTtl6bRt6d+nEVEpOvQXinabV0Knka44l9cJ2kXv9/y7p7PeWrtQXYfriF5UB/+Y8F4bs5NpXePWNfxREREzqKSFc0aquD95TDhRhgamZNq+vyWd3YfYenag+z7vI70xL488t1JXD81mZ5xMa7jiYiInJdKVjR7bxm0nIQrf+Q6Scg8Pj9v7fqMp9cdpPh4PVlJ/fnVrVO4dtII4mJVrkREpOtTyYpWjSdg2zMwbgEkXeQ6Tas1e328uaOCZeuLqKhuZNyIgSz764u5avxwYmKM63giIiKtppIVrbY9C821EXMUq7HFx+rtZTxbUMzR2iYmpw7i368bT15OEsaoXImISORRyYpGTbXw3lLIuRaGT3Sd5hudbPby8nulrNhYzPGTLUwfNZjHbp7MzKxElSsREYloKlnR6P3l0FTTpY9i1TR6eH5zCas2H6Km0cMV2UNYNCeLS0cnuo4mIiLSIVSyok1zHWx9CsbMh5FTXKc5S1V9Cys3FfPillLqmr3MvSiJhXOymJqW4DqaiIhIh1LJijbbV0JjNVz5Y9dJeOLd/TwwLzB1RGVtE7/ZWMzL75XR5PVx9YQR3DMnk/Ej4x2nFBERCQ+VrGjSUh+4hU7WXEiZ5joNS9Yc4JZLUnm2oIjV28vx+vwsmJLMPbMzyR42wHU8ERGRsFLJiiaFz0HDcZj1r05jeH1+dpadAGD2o+sA+O7FKfxwViYZQ/q5jCYiItJpVLKihacRNi+B0bMhdXqnf3xVfQvr91WybH0RBypPfhXLZwEYNrC3CpaIiHQrKlnRYscLUF8Js17olI+z1vLJZ7Ws21vJ2n2V7Co/gbUwpH8vbpqWQl5OEve8spOSh67plDwiIiJdjUpWNPA0weZfQcYVkP6tsH1MfbOXTQePs25vJev2VfJ5bTMAk1PiWZyfTV5OEhNGxmtmdhEREVSyosMHL0HdEbhxeYe/dcnxetYGS9W24ipafH4G9IrjijFDmDM2idljkxg6oNc5X7s4P7vD84iIiEQKlaxI522GTU9A2mWBI1nt1OL1s72kKlCs9lZSfLwegMyh/bjzW+nMyUkiN30wPeMufJPmL6dvEBER6Y5UsiLdrleh9jAseAraeBuayrom1u89xtq9lWw6eJyTzV56xsUwY3Qif3NZOnk5w0hL7NvBwUVERKKbSlYk83lg4+OQcgmMntPql/n9lo8O15w6WrX7cA0Awwf25juTR5KXk8TMrET69tSPh4iISFtpLxrJPlwNNWVw7eMXPIpV0+hh44HA0aqCfcf4or6FGANT0xL40VVjmTM2iYtGDNBNmUVERDqISlak8nlh42MwcmpghvevsdZysPIka/dWsnZvJTtKq/H6LfF9ejBrzFDycpKYNWYoCf16OggvIiIS/VSyItXuN6C6BOY/dOooVpPHx9biLwJzV+2tpKK6EYCc4QP4hytHk5eTxNTUQcTFXnjQuoiIiLSPSlYk8vtgw6MwfCKfJc1i7XulrNtbyeai4zR5/PTuEcPlWUO4e3Ymc8YmMXJQH9eJRUREuh2VrC7siXf3nzUNgtfnp7TgRTKriniw789Y9XDg3oCpg/twa24qc3KSmDE6kd49Yl1EFhERkSCVrC5syZoDPDBvDNX1LRTsDwxa37jvKK/7H2UvqeyJv5yfzRhOXk4SmUP7a9C6iIhIF6KS1QV5fX72HKkD4LvLtvBBWTV+C0P69+SB5L1kHz5Mw/UreW3KTMdJRURE5HxUsrqA+mYvH5SdoLC0it/tqKA8OGAdYEdpNQC3XpLK/75+PDHP/gKG5tB30o2u4oqIiEgrqGQ5cLSmicLSKgpLqiksrWLPkTp8fosxkDN8IHfMSCI3I4HFq3dR8tA1X73w07eh8lP47kqI0RWCIiIiXZlKVpj5/Zb9lXWBQlVSRWFp9ampFfr0iGVK6iDumZ1JbsZgpqYNYmDvHqdeu3j1rq/eyFooeAQSs2D8DZ29GSIiIhKiVpUsY8x8YAkQC6yw1j70td//IbAQ8AEngbustZ92cNaI0OTxsav8BDtKq9leUsXO0mpqm7wADB3Qi9z0BH4wcxS56QmMGzmQHt8wZ9Xi/OyvFvb9X/h8N9zwLMToykEREZGuzlhrv3kFY2KB/cA8oALYDnzv9BJljBlora0NPr4OuMdaO/+b3jc3N9cWFha2M757x082U1hSzY7SKraXVPPJZzV4fIHvaXZSf3IzEshNH0xuRgJpg/u27QpAa2H5bGiqgUWFEKsDkCIiIp3JGLPDWpsbymtas7eeDhy01hYHP2Q1sAA4VbK+LFhB/YBvbm4RylpL0bF6dpwaT1XNoeP1APSMi2FySjx/f8VoctMTmJaewKC+HXTLmgPvwpFdsGCpCpaIiEiEaM0eOxkoP225Arj06ysZYxYC/wT0BPI6JJ1jzV4fHx+uobCkmu0l1ewsq6aqvgWAhL49mJY+mNsuSSU3I4EJyfH0igvDaTxroeBhGJQGk27t+PcXERGRsOiwwyLW2qXAUmPM7cDPgTu/vo4x5i7gLoC0tLSO+ugOc6KhhR2lgSNUhSVVfFhRQ4vXD8CoIf3Iy0nikowEpqUPJnNov86Z/LNoLRwuhO8sgdgeF15fREREuoTWlKzDQOppyynB585nNbDsXL9hrV0OLIfAmKxWZgwLay3lVY1sD17xV1hSxYHKkwDExRgmJMfzNzPSyc0YzLT0BIYO6OUiZOAo1sAUmHx753++iIiItFlrStZ2INsYM4pAuboNOGOPb4zJttYeCC5eAxzAsa/f98/j87PnSC3bTxukfqyuGYABveOYlp7A9VOTmZaewOSUQfTp2QWu4Du0Acq3wTW/hLgOGt8lIiIineKCJcta6zXGLAL+TGAKh1XW2k+MMQ8Chdbat4FFxpi5gAeo5hynCjvbkjUHmJaecGpuqg/KTtDo8QGQktCHmZmJ5GYErvobkzSAmJgudN+/j16HNQ9CTTmYWOjR13UiERERCdEFp3AIl3BO4fDS1hL+51ufABBjYNzIgaemUchNH8zw+N5h+dwO8dHr8H/uA89Xt9ahRx/4zq9h0i3ucomIiHRj4ZrCIWI88e5+lqw580yl30J+zrAzTh12aWsePLNgQWB5zYMqWSIiIhEkqkrWA/PGnCpTGT9558z7/kWKmorQnhcREZEuSXcZ7mriU0J7XkRERLqkqC1ZZ9z3L5Lk/yIwBut0PfoEnhcREZGIEbUlK2LGYH3dpFsCg9zjUwET+KpB7yIiIhEnqsZkRY1Jt6hUiYiIRLioPZIlIiIi4pJKloiIiEgYqGSJiIiIhIFKloiIiEgYqGSJiIiIhIFKloiIiEgYqGSJiIiIhIFKloiIiEgYGGutmw825hhQGsaPGAIcD+P7d4ZI34ZIzw+Rvw2Rnh8ifxsiPT9oG7qCSM8Pkb8NY621A0J5gbMZ3621Q8P5/saYQmttbjg/I9wifRsiPT9E/jZEen6I/G2I9PygbegKIj0/RP42GGMKQ32NTheKiIiIhIFKloiIiEgYRHPJWu46QAeI9G2I9PwQ+dsQ6fkh8rch0vODtqEriPT8EPnbEHJ+ZwPfRURERKJZNB/JEhEREXEmKkuWMWa+MWafMeagMeYnrvOEyhizyhhTaYz52HWWtjDGpBpj1hljPjXGfGKMWew6U6iMMb2NMe8bYz4MbsO/u87UFsaYWGPMB8aY/3adpS2MMSXGmN3GmF1tubLHNWPMIGPMm8aYvcaYPcaYy1xnCoUxZmzwe//lr1pjzP2uc4XCGPNA8O/wx8aY14wxvV1nCoUxZnEw+yeR8r0/1z7MGDPYGPOuMeZA8GuCy4wXcp5tuDn45+A3xrTqKsmoK1nGmFhgKfBtYBzwPWPMOLepQvY8MN91iHbwAv9srR0HzAAWRuCfQTOQZ62dDEwB5htjZjjO1BaLgT2uQ7TTHGvtlAi99HsJ8CdrbQ4wmQj7s7DW7gt+76cA04AG4A+OY7WaMSYZuA/ItdZOAGKB29ymaj1jzATgH4DpBH5+rjXGZLlN1SrPc/Y+7CfAGmttNrAmuNyVPc/Z2/AxcCOwobVvEnUli8AP40FrbbG1tgVYDSxwnCkk1toNQJXrHG1lrT1ird0ZfFxHYMeS7DZVaGzAyeBij+CviBrAaIxJAa4BVrjO0h0ZY+KBK4GVANbaFmvtCbep2iUfKLLWhnMS6XCIA/oYY+KAvsBnjvOE4iJgm7W2wVrrBQoI7OS7tPPswxYALwQfvwBc36mhQnSubbDW7rHW7gvlfaKxZCUD5actVxBhO/hoYozJAKYC29wmCV3wVNsuoBJ411obadvwK+DHgN91kHawwF+MMTuMMXe5DhOiUcAx4LngKdsVxph+rkO1w23Aa65DhMJaexh4DCgDjgA11tq/uE0Vko+BK4wxicaYvsDVQKrjTG01zFp7JPj4KDDMZZjOEo0lS7oIY0x/4HfA/dbaWtd5QmWt9QVPk6QA04OH7iOCMeZaoNJau8N1lna63Fp7MYHT/wuNMVe6DhSCOOBiYJm1dipQT9c/RXJOxpiewHXAG66zhCI47mcBgcI7EuhnjPm+21StZ63dAzwM/AX4E7AL8DkN1QFsYFqDiDoz0FbRWLIOc2bTTwk+J53IGNODQMF6xVr7e9d52iN4imcdkTVObiZwnTGmhMAp8zxjzMtuI4UueCQCa20lgbFA090mCkkFUHHaEdA3CZSuSPRtYKe19nPXQUI0FzhkrT1mrfUAvwe+5ThTSKy1K62106y1VwLVwH7Xmdroc2PMCIDg10rHeTpFNJas7UC2MWZU8H9ftwFvO87UrRhjDIFxKHustY+7ztMWxpihxphBwcd9gHnAXrepWs9a+1NrbYq1NoPA34G11tqI+R88gDGmnzFmwJePgb8icPokIlhrjwLlxpixwafygU8dRmqP7xFhpwqDyoAZxpi+wX+X8omwiw+MMUnBr2kExmO96jZRm70N3Bl8fCfwlsMsncbZDaLDxVrrNcYsAv5M4EqSVdbaTxzHCokx5jVgNjDEGFMB/C9r7Uq3qUIyE7gD2B0c0wTwM2vtHx1mCtUI4IXg1aoxwOvW2oicBiGCDQP+ENg3Ege8aq39k9tIIbsXeCX4H75i4AeO84QsWHDnAf/oOkuorLXbjDFvAjsJXPX8AZE36/jvjDGJgAdYGAkXT5xrHwY8BLxujPk7oBS4xV3CCzvPNlQBTwJDgXeMMbustVd94/toxncRERGRjheNpwtFREREnFPJEhEREQkDlSwRERGRMFDJEhEREQkDlSwRERGRMFDJEhEREQkDlSwRERGRMFDJEhEREQmD/w9IIjXqJ0fc/AAAAABJRU5ErkJggg==\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, original_transfo_interpolate_accuracy)),\n",
    "    list(map(lambda l: l.value, original_transfo_interpolate_accuracy)),\n",
    "    marker='+', label='Original Transfo Interpolate Accuracy'\n",
    ")\n",
    "ax.plot(\n",
    "    list(map(lambda l: l.step, dgl_transfo_interpolate_accuracy)),\n",
    "    list(map(lambda l: l.value, dgl_transfo_interpolate_accuracy)),\n",
    "    marker='o', label='DGL Transfo Interpolate Accuracy'\n",
    ")\n",
    "plt.title('Arithmetic/Easy Interpolate Accuracy')\n",
    "ax.legend(loc='upper left', frameon=False)\n",
    "plt.xticks(np.arange(0, 12, step=1.0))\n",
    "plt.yticks(np.arange(0.3, 1.0, step=0.1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **For interpolate dataset (containing more generic questions/answers on this arithmetic problem to test generalization capabilities), it's getting more accurate faster and much higher (80% vs 60%). It's quite interesting because we see here that with DGL Transformer, it has learnt to generalise much better  in less epoch.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting state from checkpoints/dgl_transformer_arithmetic_add_or_sub_easy_2019-05-03_1000_validation_best.pth\n",
      "Loading model state_dict from state found in checkpoints/dgl_transformer_arithmetic_add_or_sub_easy_2019-05-03_1000_validation_best.pth\n"
     ]
    }
   ],
   "source": [
    "# build default transformer model\n",
    "model = utils.build_dgl_transformer()\n",
    "# restore model from checkpoint\n",
    "_ = checkpoints.restore_best_checkpoint(exp_name, unique_id, \"validation\", model)\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is 1 + 1 ['2']\n",
      "Yeah it works!\n"
     ]
    }
   ],
   "source": [
    "print(\"What is 1 + 1\", dgl_model_process.predict_single(\"What is 1 + 1\", model, device, graph_collate))\n",
    "print(\"Yeah it works!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is 10 + 10 ['200']\n",
      "WHATTTT\n"
     ]
    }
   ],
   "source": [
    "print(\"What is 10 + 10\", dgl_model_process.predict_single(\"What is 10 + 10\", model, device, graph_collate))\n",
    "\n",
    "print(\"WHATTTT\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Actually it doesn't work for basic example... I've discovered there are issues with DGL Transformer inference code using Beam Search. I haven't found why it's not working as expected for now, I need to investigate further what's going wrong in inference as training performance metrics works well. Still work to do on that topic..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "I'm not going to make any definite conclusion based on these very superficial experiments based on short trainings. Yet, it's a cool experiment as DGL Transformer, despite slow training, learns very fast and very accurate on these simple arithmetic math problems while apparently being able to generalize quite well on interpolate dataset which contains problems it has never seen. So it's quite encouraging and I want to study more about those Graph Neural Networks.\n",
    "\n",
    "I'll try to train on hard difficulty the same DGL Transformer to see if it behaves the same.\n",
    "\n",
    "Moreover, I need to run the original transformer on a longer training (more than 20epochs) to see the maximum of accuracy it can reach in interpolate mode compared to DGL Transformer.\n",
    "\n",
    "**If anyone can lend me some bigger parallel GPUs, tell me, I'll try to train those models on them to have more accurate results ;)**\n",
    "\n",
    "Next Steps:\n",
    "\n",
    "- use Attention maps to introspect learnt knowledge\n",
    "- search why inference with beam search fails for basic operations whereas training metrics work well\n",
    "\n",
    "_See you for more experiments and thanks to [DGL library](www.dgl.org) and the creators of Transformer. Not sure I'll solve all my math problems with neural networks soon but I'm having fun and learning a lot myself ;)_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}