teriyaki.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hello world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Apple Chicken:\n",
      "\n",
      "1. Preheat oven to 375 degrees.\n",
      "2. Coat chicken in flour.\n",
      "3. Place chicken in a baking dish.\n",
      "4. Cut apples into thin slices and place on top of chicken.\n",
      "5. Sprinkle with salt.\n",
      "6. Bake for 30 minutes\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Completion(texts):## Call the API key under your account (in a secure way)\n",
    "        response = openai.Completion.create(engine=\"text-davinci-002\",\n",
    "                                        prompt =  texts,\n",
    "                                        temperature = 0.6,\n",
    "                                        top_p = 1,\n",
    "                                        max_tokens = 64,\n",
    "                                        frequency_penalty = 0,\n",
    "                                        presence_penalty = 0)\n",
    "    return print(response.choices[0].text)\n",
    "\n",
    "recipe = 'Provide a cooking recipe based on the following ingredients: \\\\n \\nApple \\\n",
    "          \\n \\nFlour \\\n",
    "          \\n \\nChicken \\\n",
    "          \\n \\nSalt'\n",
    "\n",
    "GPT_Completion(recipe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate training dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create workspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir dataset\n",
    "!mkdir dataset/problems/\n",
    "!mkdir dataset/plans/\n",
    "!mkdir dataset/plans_ipc/\n",
    "!mkdir dataset/formatted/\n",
    "!mkdir dataset/plans_ipc/\n",
    "!mkdir dataset/batches\n",
    "!mkdir dataset/batches/500/problems\n",
    "!mkdir dataset/batches/500/plans\n",
    "!mkdir dataset/batches/1000/problems\n",
    "!mkdir dataset/batches/1000/plans\n",
    "!mkdir dataset/batches/2000/problems\n",
    "!mkdir dataset/batches/2000/plans\n",
    "!mkdir dataset/batches/4000/problems\n",
    "!mkdir dataset/batches/4000/plans\n",
    "!mkdir dataset/batches/8000/problems\n",
    "!mkdir dataset/batches/8000/plans\n",
    "!mkdir dataset/batches/validation/problems\n",
    "!mkdir dataset/batches/validation/plans\n",
    "!mkdir dataset/batches/validation/results/500\n",
    "!mkdir dataset/batches/validation/results/1000\n",
    "!mkdir dataset/batches/validation/results/2000\n",
    "!mkdir dataset/batches/validation/results/4000\n",
    "!mkdir dataset/batches/validation/results/8000\n",
    "!mkdir dataset/batches/validation/results/500\n",
    "!mkdir dataset/batches/validation/results/500\n",
    "!mkdir dataset/batches/validation/results/1000/plans\n",
    "!mkdir dataset/batches/validation/results/1000/val\n",
    "!mkdir dataset/batches/validation/results/2000/plans\n",
    "!mkdir dataset/batches/validation/results/2000/val\n",
    "!mkdir dataset/batches/validation/results/4000/plans\n",
    "!mkdir dataset/batches/validation/results/4000/val\n",
    "!mkdir dataset/batches/validation/results/8000/plans\n",
    "!mkdir dataset/batches/validation/results/8000/val\n",
    "!mkdir dataset/batches/validation/unsolved\n",
    "!mkdir dataset/batches/validation/unsolved/problems\n",
    "!mkdir dataset/batches/validation/unsolved/plans\n",
    "!mkdir dataset/batches/validation/unsolved/val_plans\n",
    "!mkdir dataset/batches/validation/unsolved/val\n",
    "!mkdir dataset/test/\n",
    "!mkdir dataset/test/problems\n",
    "!mkdir dataset/test/plans\n",
    "!mkdir dataset/test/val\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing conditional problem files to /home/alessio/planning/teriyaki/generator/problems/conditional...\n",
      "Done.\n",
      "All operations completed. Happy planning!\n",
      "40 duplicates deleted\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import filecmp\n",
    "\n",
    "## cleaning work directories \n",
    "!rm dataset/problems/* &> /dev/null\n",
    "!rm dataset/plans/* &> /dev/null\n",
    "!rm dataset/plans_ipc/* &> /dev/null\n",
    "!rm dataset/formatted/* &> /dev/null\n",
    "\n",
    "## 8000 data points should improve performance between 2x and 4x\n",
    "%run generator/pddl_confgen.py 4 9000 -r 24 -co\n",
    "!mv -v generator/problems/conditional/* dataset/problems > /dev/null\n",
    "\n",
    "## clean duplicates\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/problems/'))\n",
    "\n",
    "duplicates = 0\n",
    "to_be_removed = []\n",
    "\n",
    "for i, problem_i in enumerate(problems):\n",
    "    print(\"Cleaning --- \" + str(round((i / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "    for problem_j in problems[i + 1:]:\n",
    "        if filecmp.cmp('./dataset/problems/' + problem_i, \n",
    "                       './dataset/problems/' + problem_j, \n",
    "                       shallow=False):\n",
    "            duplicates += 1\n",
    "            to_be_removed.append(problem_j)\n",
    "            \n",
    "for problem in to_be_removed:\n",
    "    try:\n",
    "        os.remove('./dataset/problems/' + problem)\n",
    "    except FileNotFoundError:\n",
    "        continue\n",
    "            \n",
    "print(str(duplicates) + \" duplicates deleted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate plans with Probe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import subprocess\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/problems/'))\n",
    "\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    \n",
    "    result = subprocess.run(['./generator/probe', \n",
    "                             '-d', './dataset/domains/domain_m_25_B.pddl', \n",
    "                             '-i', './dataset/problems/' + problem,\n",
    "                             '-o', './dataset/plans/m_25_B-' + str(problem.split('_',2)[2:][0])], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    print(\"Planning --- \" + str(round((i / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "    \n",
    "#     # temporarly limit to 400 samples\n",
    "#     if i > 500: break\n",
    "\n",
    "print(\"Planning complete\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convert Probe plans to IPC format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plans converted to IPC format\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "# clean working directories\n",
    "!rm dataset/plans_ipc/* &> /dev/null\n",
    "\n",
    "plans = sorted(os.listdir('./dataset/plans/'))\n",
    "\n",
    "for plan in plans:\n",
    "    probe = open('./dataset/plans/' + plan, \"r\")\n",
    "    val = open('./dataset/plans_ipc/' + plan.split(\".\")[0] + \".plan\", 'w+')\n",
    "    replacement = \"\"\n",
    "    # using the for loop\n",
    "    action_timing = 1\n",
    "    for line in probe:\n",
    "        line = line.lower()\n",
    "        line = '%.3f' % (action_timing / 1000) + \"00: \" + line\n",
    "        val.write(line)\n",
    "        action_timing += 2\n",
    "\n",
    "    probe.close()\n",
    "    val.close()\n",
    "    \n",
    "print(\"Plans converted to IPC format\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validate and remove invalid plans using VAL Validate\n",
    "This step takes a lot of time and usually all plans are validated. **It can be skipped**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import subprocess\n",
    "\n",
    "plans = sorted(os.listdir('./dataset/plans_ipc/'))\n",
    "invalid_plans = 0\n",
    "\n",
    "for i, plan in enumerate(plans):\n",
    "    result = subprocess.run(['./generator/Validate', \n",
    "                             './dataset/domains/domain_m_25_B.pddl', \n",
    "                             './dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\",\n",
    "                             './dataset/plans_ipc/' + plan], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    if \"Plan failed to execute\" in str(result):\n",
    "        invalid_plans += 1\n",
    "#         os.remove('./dataset/plans_ipc/m_25_B-' + problem.split('_',2)[2:][0].split(\".\")[0] + \".plan\")\n",
    "#         os.remove('./dataset/problems/' + problem)\n",
    "\n",
    "    print(\"Validating --- \" + str(round((i / len(plans) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "print('%i plans could not be validated and have been removed from the dataset' % invalid_plans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sort problem & plans in batch folders\n",
    "By deafult, we created several datasets so that the total number of samples used for fine tuning doubles aeach time, starting from the minimum 500 samples up to the recommendend 8000 maximum.\n",
    "\n",
    "We also create an additional validation batch of ~1000 sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "\n",
    "## cleaning work directories \n",
    "!rm dataset/batches/500/problems/* &> /dev/null\n",
    "!rm dataset/batches/500/plans/* &> /dev/null\n",
    "!rm dataset/batches/1000/problems/* &> /dev/null\n",
    "!rm dataset/batches/1000/plans/* &> /dev/null\n",
    "!rm dataset/batches/2000/problems/* &> /dev/null\n",
    "!rm dataset/batches/2000/plans/* &> /dev/null\n",
    "!rm dataset/batches/4000/problems/* &> /dev/null\n",
    "!rm dataset/batches/4000/plans/* &> /dev/null\n",
    "!rm dataset/batches/8000/problems/* &> /dev/null\n",
    "!rm dataset/batches/8000/plans/* &> /dev/null\n",
    "!rm dataset/batches/validation/problems/* &> /dev/null\n",
    "!rm dataset/batches/validation/plans/* &> /dev/null\n",
    "!rm dataset/batches/validation/unsolved/problems/* &> /dev/null\n",
    "!rm dataset/batches/validation/unsolved/plans/* &> /dev/null\n",
    "!rm dataset/batches/validation/unsolved/val/* &> /dev/null\n",
    "!rm dataset/batches/validation/unsolved/plans_val/* &> /dev/null\n",
    "\n",
    "## fetching and sorting problems and plans\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/problems/'))\n",
    "plans = sorted(os.listdir('./dataset/plans_ipc/'))\n",
    "\n",
    "for i, plan in enumerate(plans):\n",
    "    if i < 500:\n",
    "        shutil.move('./dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     './dataset/batches/500/problems/')\n",
    "        shutil.move('./dataset/plans_ipc/' + plans[i], './dataset/batches/500/plans/')\n",
    "    elif i < 1000:\n",
    "        shutil.move('./dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     './dataset/batches/1000/problems/')\n",
    "        shutil.move('./dataset/plans_ipc/' + plans[i], './dataset/batches/1000/plans/')\n",
    "    elif i < 2000:\n",
    "        shutil.move('./dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     './dataset/batches/2000/problems/')\n",
    "        shutil.move('./dataset/plans_ipc/' + plans[i], './dataset/batches/2000/plans/')\n",
    "    elif i < 4000:\n",
    "        shutil.move('./dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     './dataset/batches/4000/problems/')\n",
    "        shutil.move('./dataset/plans_ipc/' + plans[i], './dataset/batches/4000/plans/')\n",
    "    elif i < 8000:\n",
    "        shutil.move('./dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     './dataset/batches/8000/problems/')\n",
    "        shutil.move('./dataset/plans_ipc/' + plans[i], './dataset/batches/8000/plans/')\n",
    "    else:\n",
    "        shutil.move('./dataset/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     './dataset/batches/validation/problems/')\n",
    "        shutil.move('./dataset/plans_ipc/' + plans[i], './dataset/batches/validation/plans/')\n",
    "\n",
    "## move unsolved problems to the validation folder to be attempted later by Teriyaki\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/problems/'))\n",
    "for problem in problems:\n",
    "    shutil.move('./dataset/problems/' + problem, './dataset/batches/validation/unsolved/problems/' + problem)\n",
    "    \n",
    "print('All problems and plans have been sorted into batches.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile GPT3 training datasets\n",
    "\n",
    "This step will compile `jsonl` for all training batches. Later you can use each of them to increment the fine tuning dataset size progressively.\n",
    "\n",
    "Unfortunately, before use you need to manually run in a terminal the following line for each of them:\n",
    "\n",
    "```>openai tools fine_tunes.prepare_data -f './dataset/batches/[YOUR_BATCH]/teriyaki.jsonl```\n",
    "\n",
    "=====================================================\n",
    "\n",
    "TODO: `joint3)\\n)\\n)\\n` is seen as part of the prompt\n",
    "\n",
    "From the documentation regarding conditional generation:\n",
    "* Use a separator at the end of the prompt, e.g. \\n\\n###\\n\\n. Remember to also append this separator when you eventually make requests to your model.\n",
    "* Use an ending token at the end of the completion, e.g. END\n",
    "* Remember to add the ending token as a stop sequence during inference, e.g. stop=[\" END\"]\n",
    "* Aim for at least ~500 examples\n",
    "* Ensure that the **prompt + completion doesn't exceed 2048 tokens**, including the separator\n",
    "* Ensure the examples are of high quality and follow the same desired format\n",
    "* Ensure that the dataset used for finetuning is very similar in structure and type of task as what the model will be used for\n",
    "* Using Lower learning rate and only 1-2 epochs tends to work better for these use cases\n",
    "\n",
    "Example:\n",
    "```{\"prompt\":\"<Product Name>\\n<Wikipedia description>\\n\\n###\\n\\n\", \"completion\":\" <engaging ad> END\"}```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets ready!\n",
      "Before training, run in a terminal\n",
      "\t>openai tools fine_tunes.prepare_data -f './dataset/batch/[YOUR_BATCH]/teriyaki.jsonl'\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import subprocess\n",
    "\n",
    "batches = [\"500\", \"1000\", \"2000\", \"4000\", \"8000\", \"validation\"]\n",
    "\n",
    "for batch in batches:\n",
    "    dataset = open('./dataset/batches/' + batch + '/teriyaki.jsonl', 'w+')\n",
    "    plans = sorted(os.listdir('./dataset/batches/' + batch + '/plans/'))\n",
    "\n",
    "    # extracting prompts from problems and completions from IPC plans \n",
    "    for i, plan in enumerate(plans):\n",
    "        plan_f = open('./dataset/batches/' + batch + '/plans/' + plan, \"r\")\n",
    "        problem_f = open('./dataset/batches/' + batch + '/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \"r\")\n",
    "        lines = problem_f.readlines()\n",
    "\n",
    "        # lines[49:62] is the range of meaningful predicates at initial state\n",
    "        dataset.write(repr('{\"prompt\":\"\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + \n",
    "              '\\n\\n###\\n\\n\", \"completion\":\" ' + plan_f.read().replace(\"    \", \"\") + ' END\"}')[1:-1] + \"\\n\")\n",
    "\n",
    "    dataset.close()\n",
    "\n",
    "print(\"Datasets ready!\")\n",
    "print(\"Before training, run in a terminal\\n\\t>openai tools fine_tunes.prepare_data -f './dataset/batches/[YOUR_BATCH]/teriyaki.jsonl'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a fine-tuned model!\n",
    "\n",
    "### Dataset \n",
    "From the documentation regarding conditional generation:\n",
    "* Aim for at least ~500 examples (8000 recommended)\n",
    "* Ensure that the prompt + completion doesn't exceed 2048 tokens, including the separator\n",
    "* Ensure the examples are of high quality and follow the same desired format\n",
    "* Ensure that the dataset used for finetuning is very similar in structure and type of task as what the model will be used for\n",
    "* Using Lower learning rate and only 1-2 epochs tends to work better for these use cases\n",
    "\n",
    "LEARN MORE ABOUT VALIDATION, DELETING, AND SUFFIX @ \n",
    "\n",
    "https://beta.openai.com/docs/guides/fine-tuning/advanced-usage\n",
    "\n",
    "https://beta.openai.com/docs/api-reference/fine-tunes\n",
    "\n",
    "### Training hyperparameters\n",
    "* `model` use `'davinci'` or `'code-davinci-002'` (CODEX, not yet supported)\n",
    "* `n_epochs` defaults to 4. The number of epochs to train the model for. An epoch refers to one full cycle through the training dataset. For generative use cases 2 epochs is generally better.\n",
    "* `batch_size` defaults to ~0.2% of the number of examples in the training set, capped at 256. Larger batch sizes tend to work better for larger datasets.\n",
    "* `learning_rate_multiplier`defaults to 0.05, 0.1, or 0.2 depending on final `batch_size`. We recommend experimenting with values in the range 0.02 to 0.2. Larger learning rates often perform better with larger batch sizes.\n",
    "* `compute_classification_metrics`defaults to False. If True, for fine-tuning for classification tasks, computes classification-specific metrics (accuracy, F-1 score, etc) on the validation set at the end of every epoch.\n",
    "\n",
    "### Results\n",
    "The _results.csv file contains a row for each training step, where a step refers to one forward and backward pass on a batch of data. In addition to the step number, each row contains the following fields corresponding to that step:\n",
    "\n",
    "* `elapsed_tokens`: the number of tokens the model has seen so far (including repeats)\n",
    "* `elapsed_examples`: the number of examples the model has seen so far (including repeats), where one example is one element in your batch. For example, if batch_size = 4, each step will increase elapsed_examples by 4.\n",
    "* `training_loss`: loss on the training batch\n",
    "* `training_sequence_accuracy`: the percentage of completions in the training batch for which the model's predicted tokens matched the true completion tokens exactly. For example, with a batch_size of 3, if your data contains the completions [[1, 2], [0, 5], [4, 2]] and the model predicted [[1, 1], [0, 5], [4, 2]], this accuracy will be 2/3 = 0.67\n",
    "* `training_token_accuracy`: the percentage of tokens in the training batch that were correctly predicted by the model. For example, with a batch_size of 3, if your data contains the completions [[1, 2], [0, 5], [4, 2]] and the model predicted [[1, 1], [0, 5], [4, 2]], this accuracy will be 5/6 = 0.83"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2022-11-30 23:20:17] Created fine-tune: ft-JNw1L5bGAnUwJdxSXQAQrdbj\n",
      "[2022-11-30 23:20:25] Fine-tune costs $109.78\n",
      "[2022-11-30 23:20:25] Fine-tune enqueued. Queue number: 5\n",
      "[2022-11-30 23:25:17] Fine-tune is in the queue. Queue number: 4\n",
      "[2022-12-01 00:08:39] Fine-tune is in the queue. Queue number: 3\n",
      "[2022-12-01 00:12:43] Fine-tune is in the queue. Queue number: 2\n",
      "[2022-12-01 00:13:08] Fine-tune is in the queue. Queue number: 1\n",
      "[2022-12-01 00:22:56] Fine-tune is in the queue. Queue number: 0\n",
      "[2022-12-01 00:24:34] Fine-tune started\n",
      "[2022-12-01 00:56:47] Completed epoch 1/2\n",
      "[2022-12-01 01:27:47] Completed epoch 2/2\n",
      "[2022-12-01 01:28:34] Uploaded model: davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\n",
      "[2022-12-01 01:28:36] Uploaded result file: file-ce5w8Wzv6QmWtO33b9VY5s6P\n",
      "[2022-12-01 01:28:36] Fine-tune succeeded\n",
      "\n",
      "Job complete! Status: succeeded 🎉\n",
      "Try out your fine-tuned model:\n",
      "\n",
      "openai api completions.create -m davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34 -p <YOUR_PROMPT>\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import requests\n",
    "\n",
    "# -t jsonl file of the dataset to be used for fine tuning\n",
    "# -v jsonl file of the validation dataset\n",
    "\n",
    "!openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.create -t './dataset/batches/500/teriyaki.jsonl' \\\n",
    "-v './dataset/batches/validation/teriyaki.jsonl' \\\n",
    "-m 'davinci' --suffix \"teriyaki-001\" --n_epochs 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monitor results\n",
    "Fine tuning takes time but the client disconnects after a timeout.\n",
    "\n",
    "Use the following code to reconnect and check when it's done. It can be used also for *Further tuning*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -i JOB_ID\n",
    "!openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.follow -i ft-JNw1L5bGAnUwJdxSXQAQrdbj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further tuning\n",
    "\n",
    "### <ins>Remember to update the -t argument to point to the desired batch jsonl file</ins>\n",
    "Repeat the fine tuning operation for increasingly large batches of samples.\n",
    "\n",
    "### Planning accuracy on the validation set (100/876 samples)\n",
    "\n",
    "| Training set size | Job ID | Model ID | Discarded because out of tokens, >1000 | Accuracy |\n",
    "|-------------------|--------|----------|----------------------------------------|----------|\n",
    "| **500**  | ft-PXtNnUR8jjnAzIgW1YhRpGrt | davinci:ft-teriyaki:teriyaki-001-2022-11-30-18-48-47 | 23 | 2,0%  |\n",
    "| **1000** | ft-EFuAgXbaOpytBR8VGcIq4Qfe | davinci:ft-teriyaki:teriyaki-001-2022-11-30-19-48-12 | 24 | 27,0% |\n",
    "| **2000** | ft-OkqNqBWMm0ATjHB7r2Prsgfj | davinci:ft-teriyaki:teriyaki-001-2022-11-30-21-21-23 |  9 | 59,0% |\n",
    "| **4000** | ft-cldwwOoDt4xGY2WGtTxJo5yh | davinci:ft-teriyaki:teriyaki-001-2022-11-30-22-07-22 |  3 | 84,0% |\n",
    "| **8000** | ft-JNw1L5bGAnUwJdxSXQAQrdbj | davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34 |  1 | 95,0% |\n",
    "|          |                             | **Probe planner**                                    |    | 98,6% |\n",
    "\n",
    "### Notes\n",
    "Not our case, but...\n",
    "\n",
    "```if your new training data is much smaller than your previous training data, you may find it useful to reduce learning_rate_multiplier by a factor of 2 to 4.```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upload progress: 100%|███████████████████████| 646k/646k [00:00<00:00, 307Mit/s]\n",
      "Uploaded file from ./dataset/batches/1000/teriyaki.jsonl: file-WkGWR3hD1sofGiz4lDaFCOJ9\n",
      "Found potentially duplicated files with name 'teriyaki.jsonl', purpose 'fine-tune' and size 1101044 bytes\n",
      "file-xQOM754uLyXXJezwzs1BLlSZ\n",
      "Enter file ID to reuse an already uploaded file, or an empty string to upload this file anyway: ^C\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import requests\n",
    "\n",
    "# -t jsonl file of the dataset to be used for fine tuning\n",
    "# -v jsonl file of the validation dataset\n",
    "\n",
    "!openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.create -t './dataset/batches/1000/teriyaki.jsonl' \\\n",
    "-v './dataset/batches/validation/teriyaki.jsonl' \\\n",
    "-m 'davinci:ft-teriyaki:teriyaki-001-2022-11-30-18-48-47' --suffix \"teriyaki-001\" --n_epochs 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save results\n",
    "We now download the results file for all the fine tunings performed.\n",
    "\n",
    "The `_results.csv` file contains a row for each training step, where a step refers to one forward and backward pass on a batch of data. In addition to the step number, each row contains the following fields corresponding to that step:\n",
    "\n",
    "* `elapsed_tokens`: the number of tokens the model has seen so far (including repeats)\n",
    "* `elapsed_examples`: the number of examples the model has seen so far (including repeats), where one example is one element in your batch. For example, if batch_size = 4, each step will increase elapsed_examples by 4.\n",
    "* `training_loss`: loss on the training batch\n",
    "* `training_sequence_accuracy`: the percentage of completions in the training batch for which the model's predicted tokens matched the true completion tokens exactly. For example, with a batch_size of 3, if your data contains the completions [[1, 2], [0, 5], [4, 2]] and the model predicted [[1, 1], [0, 5], [4, 2]], this accuracy will be 2/3 = 0.67\n",
    "* `training_token_accuracy`: the percentage of tokens in the training batch that were correctly predicted by the model. For example, with a batch_size of 3, if your data contains the completions [[1, 2], [0, 5], [4, 2]] and the model predicted [[1, 1], [0, 5], [4, 2]], this accuracy will be 5/6 = 0.83\n",
    "* `validation_loss`: loss on the validation batch\n",
    "* `validation_sequence_accuracy`: the percentage of completions in the validation batch for which the model's predicted tokens matched the true completion tokens exactly. For example, with a batch_size of 3, if your data contains the completion [[1, 2], [0, 5], [4, 2]] and the model predicted [[1, 1], [0, 5], [4, 2]], this accuracy will be 2/3 = 0.67\n",
    "* `validation_token_accuracy`: the percentage of tokens in the validation batch that were correctly predicted by the model. For example, with a batch_size of 3, if your data contains the completion [[1, 2], [0, 5], [4, 2]] and the model predicted [[1, 1], [0, 5], [4, 2]], this accuracy will be 5/6 = 0.83"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done!\n"
     ]
    }
   ],
   "source": [
    "response = !openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.results -i ft-PXtNnUR8jjnAzIgW1YhRpGrt > dataset/batches/500/results_500.csv\n",
    "\n",
    "response = !openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.results -i ft-EFuAgXbaOpytBR8VGcIq4Qfe > dataset/batches/1000/results_1000.csv\n",
    "\n",
    "response = !openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.results -i ft-OkqNqBWMm0ATjHB7r2Prsgfj > dataset/batches/2000/results_2000.csv\n",
    "\n",
    "response = !openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.results -i ft-cldwwOoDt4xGY2WGtTxJo5yh > dataset/batches/4000/results_4000.csv\n",
    "\n",
    "response = !openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.results -i ft-JNw1L5bGAnUwJdxSXQAQrdbj > dataset/batches/8000/results_8000.csv\n",
    "\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test it!\n",
    "This is an example of a call to the model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0.00100: (release-links link2 link1 joint1 gleft gright)\n",
      "0.00300: (link-to-central-grasp link2 link1 joint3 joint1 gleft gright)\n",
      "0.00500: (decrease_angle_first_child_45 link2 link1 joint1 angle0 angle345 angle330 angle315 gleft gright)\n",
      "0.00700: (decrease_angle_first_child link2 link1 joint1 angle315 angle300 gleft gright)\n",
      "0.00900: (decrease_angle_first_child link2 link1 joint1 angle300 angle285 gleft gright)\n",
      "0.01100: (release-links link2 link1 joint1 gleft gright)\n",
      "0.01300: (link-to-central-grasp link3 link2 joint1 joint2 gleft gright)\n",
      "0.01500: (increase_angle_first_child link3 link2 joint2 angle270 angle285 gleft gright)\n",
      "0.01700: (release-links link3 link2 joint2 gleft gright)\n",
      "0.01900: (link-to-central-grasp link4 link3 joint2 joint3 gleft gright)\n",
      "0.02100: (increase_angle_first_child link4 link3 joint3 angle300 angle315 gleft gright)\n",
      " \n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Completion(texts):## Call the API key under your account (in a secure way)\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt =  texts,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 600,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    return print(response.choices[0].text)\n",
    "\n",
    "problem = '(:init\\n(angle_joint angle0 joint1)\\n(angle_joint angle345 joint2)\\n(angle_joint angle0 joint3)\\n\\\n",
    "           (in-centre joint3)\\n(in-hand link1)\\n(in-hand link2)\\n(grasp gleft link1)\\n(grasp gright link2))\\n\\\n",
    "           (:goal(and\\n(angle_joint angle285 joint1)\\n(angle_joint angle285 joint2)\\n(angle_joint angle315 joint3)\\\n",
    "           \\n)\\n)\\n)\\n\\n\\n###\\n\\n'\n",
    "\n",
    "GPT_Completion(problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Teriyaki planning accuracy on the validation set\n",
    "Plan with Teriyaki for all available problems and run VAL Validate\n",
    "\n",
    "Te validation set is composed of 876 samples:\n",
    "* 40 problems were discarded from the original 9000 because they were duplicates\n",
    "* 84 problems were discarded from the original 9000 because Probe failed to solve them and are tested separately\n",
    "* In reality, we usually limit to 100 sample to reduce time and cost\n",
    "\n",
    "### Impact of the call parameters\n",
    "* `temperature` is set to zero to provide deterministic results\n",
    "* `max tokens` for this planning domain 1000 is usually enough but 1200 is safer. Do not increase above 1800 as call+response will exceed the maximum length allowed\n",
    "* `presence_penalty` does not seem to impact results much so I advise to keep it 0. To be confirmed but negative values lead to 1-2% worse performance while positive lead to 1-2% better performance. Might by within the noise error or depend on the domain\n",
    "* `frequency penalty` not tested but supposedly similar to `presence_penalty` in reverse\n",
    "* `best_of` does not seem to have any effect despite being advised for code completion requests\n",
    "\n",
    "### <ins>Remember to update the `engine` argument to point to the desired model</ins>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting VAL validation for batch 500\n",
      "Validating --- 11.4% --- Current success rate 2.0%\n",
      "Teriyaki failed 98 plans\n",
      "Starting VAL validation for batch 1000\n",
      "Validating --- 11.4% --- Current success rate 27.0%\n",
      "Teriyaki failed 73 plans\n",
      "Starting VAL validation for batch 2000\n",
      "Validating --- 11.4% --- Current success rate 59.0%\n",
      "Teriyaki failed 41 plans\n",
      "Starting VAL validation for batch 4000\n",
      "Validating --- 11.4% --- Current success rate 84.0%\n",
      "Teriyaki failed 16 plans\n",
      "Starting VAL validation for batch 8000\n",
      "Validating --- 11.4% --- Current success rate 95.0%\n",
      "Teriyaki failed 5 plans\n",
      "Validation complete!!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import subprocess\n",
    "\n",
    "def GPT_Plan(problem_path, model):## Call the API key under your account (in a secure way)\n",
    "    openai.api_key = \"[YOUR_API_KEY]\"\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=model,\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1000,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "snapshots = {\n",
    "    \"500\" : \"davinci:ft-teriyaki:teriyaki-001-2022-11-30-18-48-47\",\n",
    "    \"1000\": \"davinci:ft-teriyaki:teriyaki-001-2022-11-30-19-48-12\",\n",
    "    \"2000\": \"davinci:ft-teriyaki:teriyaki-001-2022-11-30-21-21-23\",\n",
    "    \"4000\": \"davinci:ft-teriyaki:teriyaki-001-2022-11-30-22-07-22\",\n",
    "    \"8000\": \"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\"\n",
    "}\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/batches/validation/problems/'))\n",
    "n_samples = 100 # limits the number of samples to reduce time and cost \n",
    "\n",
    "for batch in snapshots:\n",
    "\n",
    "    # Generating validation dataset of teriyaki plans\n",
    "    # Uncomment on first run!!\n",
    "    \n",
    "#     print(\"Generating {0} validation plans dataset using model trained over {1} samples.\".format(len(problems), batch))\n",
    "    \n",
    "#     for i, problem in enumerate(problems):\n",
    "#         if i == n_samples: ## limit number of iterations\n",
    "#             break\n",
    "#         print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)), end = '\\r')\n",
    "#         problem_path = './dataset/batches/validation/problems/' + problem\n",
    "#         plan = GPT_Plan(problem_path, snapshots[batch])\n",
    "#         plan_f = open('./dataset/batches/validation/results/{0}/plans/{1}'.format(batch, problem)[:-5] + \".plan\", 'w+')\n",
    "#         plan_f.write(plan[1:])\n",
    "#         plan_f.close()\n",
    "#     print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)))\n",
    "        \n",
    "    # Validate with VAL\n",
    "    \n",
    "    print(\"Starting VAL validation for batch {0}\".format(batch))\n",
    "    invalid_plans = 0\n",
    "    success = 0\n",
    "    for i, problem in enumerate(problems):\n",
    "        if i == n_samples: ## limit number of iterations\n",
    "            break\n",
    "        if i > 0:\n",
    "            print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "                round((i / len(problems) * 100), 1),\n",
    "                round((success / i * 100), 1)), end = '\\r')\n",
    "        result_f = open('./dataset/batches/validation/results/' + batch + '/val/' + problem, 'w+')\n",
    "        result = subprocess.run(['./generator/Validate', \n",
    "                                 './dataset/domains/domain_m_25_B.pddl', \n",
    "                                 './dataset/batches/validation/problems/' + problem,\n",
    "                                 './dataset/batches/validation/results/{0}/plans/{1}'.format(batch, problem)[:-5] + \".plan\"], \n",
    "                                 stdout=subprocess.PIPE)\n",
    "        result_f.write(str(result))\n",
    "        result_f.close()\n",
    "        if (\"Plan failed to execute\" in str(result)) or (\"Bad plan description!\" in str(result)):\n",
    "            invalid_plans += 1\n",
    "        else:\n",
    "            success += 1\n",
    "    print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "        round((i / len(problems) * 100), 1),\n",
    "        round((success / i * 100), 1)))\n",
    "\n",
    "    print('Teriyaki failed %i plans' % invalid_plans)\n",
    "    \n",
    "print(\"Validation complete!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Teriyaki planning accuracy on the test set (1000 samples)\n",
    "\n",
    "| Training set size | Job ID | Model ID | Discarded because out of tokens, >1200 | Accuracy |\n",
    "|-------------------|--------|----------|----------------------------------------|----------|\n",
    "| **8000** | ft-JNw1L5bGAnUwJdxSXQAQrdbj | davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34 | 8 | 95,5% |\n",
    "|          |                             | **Probe planner**                                    |   | 98,6% |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting VAL validation on the generated dataset.\n",
      "Validating --- 99.9% --- Current success rate 95.5%\n",
      "Teiyaki failed 46 plans\n",
      "Validation complete!!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import subprocess\n",
    "\n",
    "# Uncomment only if you need to generate a new test set\n",
    "# %run generator/pddl_confgen.py 4 1000 -r 24 -co\n",
    "# !mv -v generator/problems/conditional/* dataset/test/problems > /dev/null\n",
    "\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    openai.api_key = \"[YOUR_API_KEY]\"\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1200,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/test/problems/'))\n",
    "\n",
    "# Teriyaki planning\n",
    "\n",
    "print(\"Planning {0} problems with Teriyaki.\".format(len(problems)))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)), end = '\\r')\n",
    "    problem_path = './dataset/test/problems/' + problem\n",
    "    plan = GPT_Plan(problem_path)\n",
    "    plan_f = open('./dataset/test/plans/{0}'.format(problem)[:-5] + \".plan\", 'w+')\n",
    "    plan_f.write(plan[1:])\n",
    "    plan_f.close()\n",
    "print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)))\n",
    "\n",
    "# Validate with VAL\n",
    "\n",
    "print(\"Starting VAL validation on the generated dataset.\")\n",
    "invalid_plans = 0\n",
    "success = 0\n",
    "for i, problem in enumerate(problems):\n",
    "    if i > 0:\n",
    "        print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "            round((i / len(problems) * 100), 1),\n",
    "            round((success / i * 100), 1)), end = '\\r')\n",
    "    result_f = open('./dataset/test/val/' + problem, 'w+')\n",
    "    result = subprocess.run(['./generator/Validate', \n",
    "                             './dataset/domains/domain_m_25_B.pddl', \n",
    "                             './dataset/test/problems/' + problem,\n",
    "                             './dataset/test/plans/{0}'.format(problem)[:-5] + \".plan\"], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    result_f.write(str(result))\n",
    "    result_f.close()\n",
    "    if (\"Plan failed to execute\" in str(result)) or (\"Bad plan description!\" in str(result)):\n",
    "        invalid_plans += 1\n",
    "    else:\n",
    "        success += 1\n",
    "print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "    round((i / len(problems) * 100), 1),\n",
    "    round((success / i * 100), 1)))\n",
    "\n",
    "print('Teiyaki failed %i plans' % invalid_plans)\n",
    "\n",
    "print(\"Validation complete!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Teriyaki success rate on problems failed by probe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting VAL validation on the generated dataset.\n",
      "Validating --- 98.8% --- Current success rate 98.8%%\n",
      "Teriyaki failed 2 plans\n",
      "Validation complete!!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import subprocess\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1200,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/batches/validation/unsolved/problems/'))\n",
    "\n",
    "# Planning with Teriyaki\n",
    "\n",
    "print(\"Generating {0} validation plans dataset using model trained over 8000 samples.\".format(len(problems)))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)), end = '\\r')\n",
    "    problem_path = './dataset/batches/validation/unsolved/problems/' + problem\n",
    "    plan = GPT_Plan(problem_path)\n",
    "    plan_f = open('./dataset/batches/validation/unsolved/plans/{0}'.format(problem)[:-5] + \".plan\", 'w+')\n",
    "    plan_f.write(plan[1:])\n",
    "    plan_f.close()\n",
    "print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)))\n",
    "\n",
    "# Validate with VAL\n",
    "\n",
    "print(\"Starting VAL validation on the generated dataset.\")\n",
    "invalid_plans = 0\n",
    "success = 0\n",
    "for i, problem in enumerate(problems):\n",
    "    if i > 0:\n",
    "        print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "            round((i / len(problems) * 100), 1),\n",
    "            round((success / i * 100), 1)), end = '\\r')\n",
    "    result_f = open('./dataset/batches/validation/unsolved/val/' + problem, 'w+')\n",
    "    result = subprocess.run(['./generator/Validate', \n",
    "                             './dataset/domains/domain_m_25_B.pddl', \n",
    "                             './dataset/batches/validation/unsolved/problems/' + problem,\n",
    "                             './dataset/batches/validation/unsolved/plans/{0}'.format(problem)[:-5] + \".plan\"], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    result_f.write(str(result))\n",
    "    result_f.close()\n",
    "    if (\"Plan failed to execute\" in str(result)) or (\"Bad plan description!\" in str(result)):\n",
    "        invalid_plans += 1\n",
    "    else:\n",
    "        success += 1\n",
    "        \n",
    "print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "    round((i / len(problems) * 100), 1),\n",
    "    round((success / i * 100), 1)))\n",
    "\n",
    "print('Teriyaki failed %i plans' % invalid_plans)\n",
    "    \n",
    "print(\"Validation complete!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare planning times and length\n",
    "| Test |       Date | Start time | End time |\n",
    "|------|------------|------------|----------|\n",
    "|    1 | 18/02/2023 |   11:17:56 | 13:47:41 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 problems loaded\n",
      "Running Probe tests --- 100%%\n",
      "Starting GPT test at 11:17:56\n",
      "WARNING: the query for problem ./dataset/test/problems/problem_conditional_4_24_00711.pddl has exceed the max_tokens limit.\n",
      "Running Teriyaki tests --- 100%%\n",
      "Finished GPT test at 13:47:41\n",
      "Tests completed\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import subprocess\n",
    "import os\n",
    "import openai\n",
    "import time\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    openai.api_key = \"[YOUR_API_KEY]\"\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1900,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/test/problems/'))\n",
    "n_samples = 1000 ## limit number of samples\n",
    "print(\"{0} problems loaded\".format(min(n_samples, len(problems))))\n",
    "\n",
    "results = np.empty([2,6])\n",
    "timings = np.empty([min(n_samples, len(problems)),2])\n",
    "\n",
    "### Test Probe\n",
    "\n",
    "comparison_results = []\n",
    "planning_times = []\n",
    "planning_steps = []\n",
    "fails = 0\n",
    "\n",
    "print(\"Running Probe tests --- 0%\", end = '\\r')\n",
    "for j, problem in enumerate(problems):\n",
    "    if j == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    result = subprocess.run(['./generator/probe', \n",
    "                             '-d', './dataset/domains/domain_m_25_B.pddl', \n",
    "                             '-i', './dataset/test/problems/' + problem,\n",
    "                             '-o', './dataset/test/probe/m_25_B-' + str(problem.split('_',2)[2:][0])], \n",
    "                             stdout=subprocess.PIPE)\n",
    "\n",
    "    # considering failures plans that took more than 1sec or that failed planning\n",
    "    try:\n",
    "        planning_steps.append(float(result.stdout.decode(\"utf8\").split('steps: ')[1].split('\\n')[0]))\n",
    "        ptime = float(result.stdout.decode(\"utf8\").split('Time: ')[1].split('\\n')[0])\n",
    "        planning_times.append(ptime)\n",
    "\n",
    "    except IndexError:\n",
    "        planning_times.append(np.nan) \n",
    "        fails+=1\n",
    "\n",
    "    print(\"Running Probe tests --- \" + str(round((j / min(n_samples, len(problems)) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "print(\"Running Probe tests --- 100%\")\n",
    "timings[:,0] = planning_times\n",
    "\n",
    "planning_times = np.array(planning_times)\n",
    "planning_steps = np.array(planning_steps)\n",
    "\n",
    "comparison_results.append(np.nanmean(planning_steps))\n",
    "comparison_results.append(np.nanmin(planning_times))\n",
    "comparison_results.append(np.nanmax(planning_times))\n",
    "comparison_results.append(np.nanmean(planning_times))\n",
    "comparison_results.append(np.nanstd(planning_times))\n",
    "\n",
    "comparison_results.append(fails)\n",
    "\n",
    "results[0] = comparison_results\n",
    "\n",
    "### Test Teriyaki\n",
    "\n",
    "comparison_results = []\n",
    "planning_times = []\n",
    "planning_steps = []\n",
    "fails = 0\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%H:%M:%S\", t)\n",
    "print(\"Starting GPT test at \" + current_time)\n",
    "\n",
    "print(\"Running Teriyaki tests --- 0%\", end = '\\r')\n",
    "for j, problem in enumerate(problems):\n",
    "    if j == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    st = time.time()\n",
    "    result = GPT_Plan('./dataset/test/problems/' + problem)\n",
    "    et = time.time()\n",
    "    # considering failures plans that took more than 1sec or that failed planning\n",
    "    try:\n",
    "        planning_steps.append(float(result.count('\\n')))\n",
    "        planning_times.append(et - st)\n",
    "\n",
    "    except IndexError:\n",
    "        planning_times.append(np.nan) \n",
    "        fails+=1\n",
    "\n",
    "    print(\"Running Teriyaki tests --- \" + str(round((j / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "print(\"Running Teriyaki tests --- 100%\")\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%H:%M:%S\", t)\n",
    "print(\"Finished GPT test at \" + current_time)\n",
    "\n",
    "timings[:,1] = planning_times\n",
    "\n",
    "planning_times = np.array(planning_times)\n",
    "planning_steps = np.array(planning_steps)\n",
    "\n",
    "comparison_results.append(np.nanmean(planning_steps))\n",
    "comparison_results.append(np.nanmin(planning_times))\n",
    "comparison_results.append(np.nanmax(planning_times))\n",
    "comparison_results.append(np.nanmean(planning_times))\n",
    "comparison_results.append(np.nanstd(planning_times))\n",
    "\n",
    "comparison_results.append(fails)\n",
    "\n",
    "results[1] = comparison_results\n",
    "\n",
    "with open('./timings/results.npy', 'wb') as f:\n",
    "    np.save(f, results)\n",
    "    \n",
    "with open('./timings/timings.npy', 'wb') as f:\n",
    "    np.save(f, timings)\n",
    "    \n",
    "print(\"Tests completed\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_23cf3\" style=\"font-size: 20px\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_23cf3_level0_col0\" class=\"col_heading level0 col0\" >SOLVER</th>\n",
       "      <th id=\"T_23cf3_level0_col1\" class=\"col_heading level0 col1\" >avg_steps</th>\n",
       "      <th id=\"T_23cf3_level0_col2\" class=\"col_heading level0 col2\" >min</th>\n",
       "      <th id=\"T_23cf3_level0_col3\" class=\"col_heading level0 col3\" >max</th>\n",
       "      <th id=\"T_23cf3_level0_col4\" class=\"col_heading level0 col4\" >avg</th>\n",
       "      <th id=\"T_23cf3_level0_col5\" class=\"col_heading level0 col5\" >std</th>\n",
       "      <th id=\"T_23cf3_level0_col6\" class=\"col_heading level0 col6\" >fails</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_23cf3_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_23cf3_row0_col0\" class=\"data row0 col0\" >Probe</td>\n",
       "      <td id=\"T_23cf3_row0_col1\" class=\"data row0 col1\" >11.111</td>\n",
       "      <td id=\"T_23cf3_row0_col2\" class=\"data row0 col2\" >0.009</td>\n",
       "      <td id=\"T_23cf3_row0_col3\" class=\"data row0 col3\" >36.711</td>\n",
       "      <td id=\"T_23cf3_row0_col4\" class=\"data row0 col4\" >2.112</td>\n",
       "      <td id=\"T_23cf3_row0_col5\" class=\"data row0 col5\" >3.470</td>\n",
       "      <td id=\"T_23cf3_row0_col6\" class=\"data row0 col6\" >12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_23cf3_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "      <td id=\"T_23cf3_row1_col0\" class=\"data row1 col0\" >Teiryaki</td>\n",
       "      <td id=\"T_23cf3_row1_col1\" class=\"data row1 col1\" >10.953</td>\n",
       "      <td id=\"T_23cf3_row1_col2\" class=\"data row1 col2\" >1.033</td>\n",
       "      <td id=\"T_23cf3_row1_col3\" class=\"data row1 col3\" >54.323</td>\n",
       "      <td id=\"T_23cf3_row1_col4\" class=\"data row1 col4\" >8.985</td>\n",
       "      <td id=\"T_23cf3_row1_col5\" class=\"data row1 col5\" >4.770</td>\n",
       "      <td id=\"T_23cf3_row1_col6\" class=\"data row1 col6\" >0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f7d77027310>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "results = np.load('./timings/results.npy')\n",
    "\n",
    "results_table = pd.DataFrame(results, columns=('avg_steps', 'min', 'max', 'avg', 'std', 'fails'))\n",
    "\n",
    "df = pd.DataFrame({'SOLVER': ('Probe', 'Teiryaki')})\n",
    "df = pd.concat([df, results_table],axis=1)\n",
    "df = df.astype({\"fails\":\"int\"})\n",
    "\n",
    "df.style.\\\n",
    "    format(precision=3).\\\n",
    "    set_table_attributes('style=\"font-size: 20px\"')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results boxplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dft = pd.DataFrame(timings, columns=['Probe','Teriyaki'])\n",
    "\n",
    "timings = np.load('./timings/timings.npy')\n",
    "\n",
    "props = dict(boxes=\"DarkBlue\", \n",
    "             whiskers=\"DarkBlue\", \n",
    "             medians=\"Yellow\", \n",
    "             caps=\"Gray\")\n",
    "\n",
    "boxplot = dft.plot.box(figsize=(16,9), \n",
    "                       fontsize=20, \n",
    "                       color=props, \n",
    "                       patch_artist=True,\n",
    "                       xlabel=\"Solver\",\n",
    "                       ylabel=\"seconds\",\n",
    "                       showfliers=False)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Did we impact the natural language capabilities of GPT?\n",
    "\n",
    "Yes. The output has been deleted for brevity as it is very long, but Teriyaki loses the ability to answer to natural language questions in any meaningful way. \n",
    "\n",
    "\"Mixed queries\" are queries where we ask the system using natural language to reason about the plan to be generated. For example, we ask in natural language to provide only the last action of the plan that solves a given problem, followed by the problem in PDDL format. Unfortunately this does not work either at the moment.\n",
    "\n",
    "A possible interpretation that follows from the discussion in the paper is that GPT is not really reasoning abot the problem itself and what is going on, but is just learning the heuristics used by the planner to solve the problem. Further reasoning on plan and problem is not included. It is possible that with an ad-hoc fine tuning this could work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import subprocess\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Completion(texts):## Call the API key under your account (in a secure way)\n",
    "    response = openai.Completion.create(engine=\"text-davinci-002\",\n",
    "                                        prompt =  texts,\n",
    "                                        temperature = 0.6,\n",
    "                                        top_p = 1,\n",
    "                                        max_tokens = 600,\n",
    "                                        frequency_penalty = 0,\n",
    "                                        presence_penalty = 0,\n",
    "                                        stop = \"END\")\n",
    "    return print(response.choices[0].text)\n",
    "\n",
    "def Teriyaki_Completion(texts):## Call the API key under your account (in a secure way)\n",
    "    openai.api_key = \"[YOUR_API_KEY]\"\n",
    "\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt =  texts,\n",
    "                                        temperature = 0.6,\n",
    "                                        top_p = 1,\n",
    "                                        max_tokens = 600,\n",
    "                                        frequency_penalty = 0,\n",
    "                                        presence_penalty = 0,\n",
    "                                        stop = \"END\")\n",
    "    return print(response.choices[0].text)\n",
    "\n",
    "query = \"What is a Large Language Model?\"\n",
    "\n",
    "print(\"GPT Davinci:\\n\")\n",
    "GPT_Completion(query)\n",
    "\n",
    "print(\"\\n===========\\nTeriyaki:\\n\")\n",
    "Teriyaki_Completion(query)\n",
    "\n",
    "print(\"\\nTesting queries that mix natural language and our planning model\\n\")\n",
    "\n",
    "mixed_query = \"If you solve this problem, what would be the last action taken?\\n\\\n",
    "               Problem:\\n\\\n",
    "               (:init\\n(angle_joint angle0 joint1)\\n(angle_joint angle345 joint2)\\n(angle_joint angle0 joint3)\\n\\\n",
    "               (in-centre joint3)\\n(in-hand link1)\\n(in-hand link2)\\n(grasp gleft link1)\\n(grasp gright link2))\\n\\\n",
    "               (:goal(and\\n(angle_joint angle285 joint1)\\n(angle_joint angle285 joint2)\\n(angle_joint angle315 joint3\\\n",
    "               )\\n)\\n)\\n)\\n\\n\\n###\\n\\n\" ## The prompt ending we used in training should suggest to recall that \n",
    "\n",
    "print(\"\\n===========\\nGPT Davinci mixed query:\")\n",
    "GPT_Completion(mixed_query)\n",
    "\n",
    "print(\"\\n===========\\nTeriyaki Mixed query:\")\n",
    "Teriyaki_Completion(mixed_query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transfer learning - No macro\n",
    "\n",
    "### Learning from scratch\n",
    "\n",
    "| Training set size | Job ID | Model ID | Accuracy |\n",
    "|-------------------|----------------------------|------------------------------------------------------|-------|\n",
    "| No macro - 1000   |ft-3fwBVR15jYUsva3pUC6OsTb4 | davinci:ft-teriyaki:teriyaki-003-2023-02-08-16-04-36 | 32.5% |\n",
    "|                   |                            | **Probe planner**                                    | 98,6% |\n",
    "\n",
    "### Learning from Teriyaki-001\n",
    "\n",
    "| Training set size | Job ID | Model ID | Accuracy |\n",
    "|-------------------|---------------------------|------------------------------------------------------|-------|\n",
    "| No macro - 1000 | ft-fnYjeF0c5JHLVivXYtcURsQG | davinci:ft-teriyaki:teriyaki-002-2023-02-07-13-55-29 | 95.2% |\n",
    "| No macro - 2000 | ft-ZdKuOAYYbedWMPvw0Pm2EV8c | davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07 | 98.8% |\n",
    "|                 |                             | **Probe planner**                                    | 98,6% |\n",
    "\n",
    "Run as many time as needed, but remember to update the base model in the call at the end!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing conditional problem files to /home/alessio/planning/teriyaki/generator/problems/conditional...\n",
      "Done.\n",
      "All operations completed. Happy planning!\n",
      "Planning --- 35.6%\r"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "terminate called after throwing an instance of 'std::bad_alloc'\n",
      "  what():  std::bad_alloc\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plans converted to IPC format\n",
      "Datasets ready!\n",
      "Before training, run in a terminal\n",
      "\t>openai tools fine_tunes.prepare_data -f './dataset/batches/[YOUR_BATCH]/teriyaki.jsonl'\n",
      "Upload progress: 100%|████████████████████| 2.11M/2.11M [00:00<00:00, 2.85Git/s]\n",
      "Uploaded file from ./dataset/batches/no_macro/teriyaki_no_macro.jsonl: file-QOcI8DCY5VZmg26iDHdMD5gQ\n",
      "Found potentially duplicated files with name 'teriyaki_no_macro.jsonl', purpose 'fine-tune' and size 194536 bytes\n",
      "file-DMReY0ylJ69c7yJDg8TNhXUm\n",
      "Enter file ID to reuse an already uploaded file, or an empty string to upload this file anyway: ^C\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!rm -r dataset/batches/no_macro &> /dev/null\n",
    "!rm -r dataset/batches/validation/no_macro &> /dev/null\n",
    "!rm -r dataset/batches/validation/results/no_macro\n",
    "!mkdir dataset/batches/no_macro/\n",
    "!mkdir dataset/batches/no_macro/problems\n",
    "!mkdir dataset/batches/no_macro/plans\n",
    "!mkdir dataset/batches/no_macro/plans_ipc\n",
    "!mkdir dataset/batches/validation/results/no_macro\n",
    "!mkdir dataset/batches/validation/results/no_macro/plans\n",
    "!mkdir dataset/batches/validation/results/no_macro/val\n",
    "!mkdir dataset/batches/validation/no_macro\n",
    "!mkdir dataset/batches/validation/no_macro/plans\n",
    "!mkdir dataset/batches/validation/no_macro/problems\n",
    "\n",
    "import os\n",
    "import subprocess\n",
    "import shutil\n",
    "import openai\n",
    "import requests\n",
    "\n",
    "## generate problems\n",
    "\n",
    "%run generator/pddl_confgen.py 4 1000 -r 24 -co\n",
    "!mv -v generator/problems/conditional/* dataset/batches/no_macro/problems > /dev/null\n",
    "\n",
    "## generate plans\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/batches/no_macro/problems'))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    \n",
    "    result = subprocess.run(['./generator/probe', \n",
    "                             '-d', './dataset/domains/domain_m_0.pddl', \n",
    "                             '-i', './dataset/batches/no_macro/problems/' + problem,\n",
    "                             '-o', './dataset/batches/no_macro/plans/m_0-' + str(problem.split('_',2)[2:][0])], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    print(\"Planning --- \" + str(round((i / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "## convert to IPC    \n",
    "    \n",
    "plans = sorted(os.listdir('./dataset/batches/no_macro/plans/'))\n",
    "\n",
    "for plan in plans:\n",
    "    probe = open('./dataset/batches/no_macro/plans/' + plan, \"r\")\n",
    "    val = open('./dataset/batches/no_macro/plans_ipc/' + plan.split(\".\")[0] + \".plan\", 'w+')\n",
    "    replacement = \"\"\n",
    "    # using the for loop\n",
    "    action_timing = 1\n",
    "    for line in probe:\n",
    "        line = line.lower()\n",
    "        line = '%.3f' % (action_timing / 1000) + \"00: \" + line\n",
    "        val.write(line)\n",
    "        action_timing += 2\n",
    "\n",
    "    probe.close()\n",
    "    val.close()\n",
    "    \n",
    "print(\"Plans converted to IPC format\")\n",
    "\n",
    "## sort plans\n",
    "## Uncomment only if you need to generate a validation dataset\n",
    "\n",
    "plans_ipc = sorted(os.listdir('./dataset/batches/no_macro/plans_ipc/'))\n",
    "\n",
    "for i, plan in enumerate(plans_ipc):\n",
    "    if i < 1000:\n",
    "        continue\n",
    "    else:\n",
    "        shutil.move('./dataset/batches/no_macro/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     'dataset/batches/validation/no_macro/problems/')\n",
    "        shutil.move('./dataset/batches/no_macro/plans_ipc/' + plans_ipc[i], 'dataset/batches/validation/no_macro/plans/')\n",
    "\n",
    "print('All problems and plans have been sorted into batches.')\n",
    "\n",
    "# compile datasets\n",
    "\n",
    "dataset = open('./dataset/batches/no_macro/teriyaki_no_macro.jsonl', 'w+')\n",
    "plans_ipc = sorted(os.listdir('./dataset/batches/no_macro/plans_ipc/'))\n",
    "\n",
    "for i, plan in enumerate(plans_ipc):\n",
    "    plan_f = open('./dataset/batches/no_macro/plans_ipc/' + plan, \"r\")\n",
    "    problem_f = open('./dataset/batches/no_macro/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \"r\")\n",
    "    lines = problem_f.readlines()\n",
    "\n",
    "    dataset.write(repr('{\"prompt\":\"\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + \n",
    "          '\\n\\n###\\n\\n\", \"completion\":\" ' + plan_f.read().replace(\"    \", \"\") + ' END\"}')[1:-1] + \"\\n\")\n",
    "\n",
    "dataset.close()\n",
    "\n",
    "dataset = open('./dataset/batches/validation/no_macro/teriyaki_no_macro.jsonl', 'w+')\n",
    "plans_ipc = sorted(os.listdir('./dataset/batches/validation/no_macro/plans/'))\n",
    "\n",
    "for i, plan in enumerate(plans_ipc):\n",
    "    plan_f = open('./dataset/batches/validation/no_macro/plans/' + plan, \"r\")\n",
    "    problem_f = open('./dataset/batches/validation/no_macro/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \"r\")\n",
    "    lines = problem_f.readlines()\n",
    "\n",
    "    dataset.write(repr('{\"prompt\":\"\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + \n",
    "          '\\n\\n###\\n\\n\", \"completion\":\" ' + plan_f.read().replace(\"    \", \"\") + ' END\"}')[1:-1] + \"\\n\")\n",
    "\n",
    "dataset.close()\n",
    "\n",
    "print(\"Datasets ready!\")\n",
    "print(\"Before training, run in a terminal\\n\\t>openai tools fine_tunes.prepare_data -f './dataset/batches/[YOUR_BATCH]/teriyaki.jsonl'\")\n",
    "\n",
    "# fine-tune starting from previous model\n",
    "\n",
    "!openai -k [YOUR_API_KEY] \\\n",
    "api fine_tunes.create -t './dataset/batches/no_macro/teriyaki_no_macro.jsonl' \\\n",
    "-v './dataset/batches/validation/no_macro/teriyaki_no_macro.jsonl' \\\n",
    "-m 'davinci' --suffix \"teriyaki-003\" --n_epochs 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check Teriyaki no macro planning accuracy on the validation set\n",
    "Update `engine` field and uncomment sections as needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating 84 validation plans dataset using no macro model.\n",
      "GPT-Planning --- 98.8%\n",
      "Starting VAL validation on the generated dataset.\n",
      "Validating --- 98.8% --- Current success rate 98.8%%\n",
      "Teriyaki-no-macro failed to plan 2 problems\n",
      "Validation complete!!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import subprocess\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1800, # increased to accomodate for longer plans\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/batches/validation/no_macro/problems/'))\n",
    "\n",
    "# Generating validation dataset of plans\n",
    "\n",
    "print(\"Generating {0} validation plans dataset using no macro model.\".format(len(problems)))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)), end = '\\r')\n",
    "    problem_path = './dataset/batches/validation/no_macro/problems/' + problem\n",
    "    plan = GPT_Plan(problem_path)\n",
    "    plan_f = open('./dataset/batches/validation/results/no_macro/plans/{0}'.format(problem)[:-5] + \".plan\", 'w+')\n",
    "    plan_f.write(plan[1:])\n",
    "    plan_f.close()\n",
    "print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)))\n",
    "\n",
    "# Validate with VAL\n",
    "\n",
    "print(\"Starting VAL validation on the generated dataset.\")\n",
    "invalid_plans = 0\n",
    "success = 0\n",
    "for i, problem in enumerate(problems):\n",
    "    if i > 0:\n",
    "        print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "            round((i / len(problems) * 100), 1),\n",
    "            round((success / i * 100), 1)), end = '\\r')\n",
    "    result_f = open('./dataset/batches/validation/results/no_macro/val/' + problem, 'w+')\n",
    "    result = subprocess.run(['./generator/Validate', \n",
    "                             './dataset/domains/domain_m_0.pddl', \n",
    "                             './dataset/batches/validation/no_macro/problems/' + problem,\n",
    "                             './dataset/batches/validation/results/no_macro/plans/{0}'.format(problem)[:-5] + \".plan\"], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    result_f.write(str(result))\n",
    "    result_f.close()\n",
    "    if (\"Plan failed to execute\" in str(result)) or (\"Bad plan description!\" in str(result)):\n",
    "        invalid_plans += 1\n",
    "    else:\n",
    "        success += 1\n",
    "print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "    round((i / len(problems) * 100), 1),\n",
    "    round((success / i * 100), 1)))\n",
    "\n",
    "print('Teriyaki-no-macro failed to plan %i problems' % invalid_plans)\n",
    "    \n",
    "print(\"Validation complete!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check Teriyaki no macro planning accuracy on test set\n",
    "The accuracy reported in the paper has been calculated over 1000 samples. The code below has been limited to 100 samples for faster iteration.\n",
    "\n",
    "### Learning from Teriyaki-001\n",
    "\n",
    "| Training set size | Job ID | Model ID | Accuracy |\n",
    "|-------------------|---------------------------|------------------------------------------------------|-------|\n",
    "| No macro - 2000 | ft-ZdKuOAYYbedWMPvw0Pm2EV8c | davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07 | 94,0% |\n",
    "|                 |                             | **Probe planner**                                    | 98,6% |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Planning 100 problems with Teriyaki.\n",
      "GPT-Planning --- 10.0%\n",
      "Starting VAL validation on the generated dataset.\n",
      "Validating --- 10.0% --- Current success rate 94.0%\n",
      "Teiyaki failed 6 plans\n",
      "Validation complete!!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import subprocess\n",
    "\n",
    "# Uncomment only if you need to generate a new test set\n",
    "# %run generator/pddl_confgen.py 4 1000 -r 24 -co\n",
    "# !mv -v generator/problems/conditional/* dataset/test/problems > /dev/null\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1800,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "n_samples = 100 ## limit number of test samples\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/test/problems/'))\n",
    "\n",
    "# Teriyaki planning\n",
    "\n",
    "print(\"Planning {0} problems with Teriyaki.\".format(min(n_samples, len(problems))))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    if i == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)), end = '\\r')\n",
    "    problem_path = './dataset/test/problems/' + problem\n",
    "    plan = GPT_Plan(problem_path)\n",
    "    plan_f = open('./dataset/test/plans_no_macro/{0}'.format(problem)[:-5] + \".plan\", 'w+')\n",
    "    plan_f.write(plan[1:])\n",
    "    plan_f.close()\n",
    "print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)))\n",
    "\n",
    "# Validate with VAL\n",
    "\n",
    "print(\"Starting VAL validation on the generated dataset.\")\n",
    "invalid_plans = 0\n",
    "success = 0\n",
    "for i, problem in enumerate(problems):\n",
    "    if i == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    if i > 0:\n",
    "        print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "            round((i / len(problems) * 100), 1),\n",
    "            round((success / i * 100), 1)), end = '\\r')\n",
    "    result_f = open('./dataset/test/val/' + problem, 'w+')\n",
    "    result = subprocess.run(['./generator/Validate', \n",
    "                             './dataset/domains/domain_m_0.pddl', \n",
    "                             './dataset/test/problems/' + problem,\n",
    "                             './dataset/test/plans_no_macro/{0}'.format(problem)[:-5] + \".plan\"], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    result_f.write(str(result))\n",
    "    result_f.close()\n",
    "    if (\"Plan failed to execute\" in str(result)) or (\"Bad plan description!\" in str(result)):\n",
    "        invalid_plans += 1\n",
    "    else:\n",
    "        success += 1\n",
    "print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "    round((i / len(problems) * 100), 1),\n",
    "    round((success / i * 100), 1)))\n",
    "\n",
    "print('Teiyaki failed %i plans' % invalid_plans)\n",
    "\n",
    "print(\"Validation complete!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting classification metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "f500 = \"./dataset/batches/500/results_500.csv\"\n",
    "f1000 = \"./dataset/batches/1000/results_1000.csv\"\n",
    "f2000 = \"./dataset/batches/2000/results_2000.csv\"\n",
    "f4000 = \"./dataset/batches/4000/results_4000.csv\"\n",
    "f8000 = \"./dataset/batches/8000/results_8000.csv\"\n",
    "\n",
    "batches = [f1000, f2000, f4000, f8000]\n",
    "\n",
    "df_append = pd.DataFrame()\n",
    "\n",
    "df_temp = pd.read_csv(f500)\n",
    "df_append = pd.concat([df_append, df_temp], ignore_index=True)\n",
    "\n",
    "for batch in batches:\n",
    "    df_temp = pd.read_csv(batch)\n",
    "    df_temp[\"step\"] += df_append[\"step\"].iloc[-1]\n",
    "    df_temp[\"elapsed_tokens\"] += df_append[\"elapsed_tokens\"].iloc[-1]\n",
    "    df_temp[\"elapsed_examples\"] += df_append[\"elapsed_examples\"].iloc[-1]\n",
    "    df_append = pd.concat([df_append, df_temp], ignore_index=True)\n",
    "\n",
    "# df_append[\"elapsed_examples\"] = df_append[\"elapsed_examples\"] / 2\n",
    "df_append = df_append.dropna()\n",
    "q1 = df_append[\"validation_token_accuracy\"].quantile(0.001)\n",
    "q2 = df_append[\"validation_token_accuracy\"].quantile(0.999)\n",
    "df_append = df_append[(df_append[\"validation_token_accuracy\"] > q1) & (df_append[\"validation_token_accuracy\"] < q2)]\n",
    "\n",
    "df_pacc = pd.DataFrame({\n",
    "    'elapsed_examples': [1002, 2004, 4008, 8012, 16020],\n",
    "    'planning_accuracy': [0.02, 0.27, 0.59, 0.84, 0.95],\n",
    "    'n_failures': [23, 24, 9, 3, 1]\n",
    "})\n",
    "\n",
    "\n",
    "plot = df.plot(x=\"elapsed_examples\", y=[\"validation_token_accuracy\"], \n",
    "                      figsize=(16,10), \n",
    "                      fontsize=14,\n",
    "                      xticks=[1000, 2000, 4000, 8000, 16000])\n",
    "plot.legend(loc=2, prop={'size': 20})\n",
    "plot.set_xlabel('elapsed_examples',fontdict={'fontsize':16})\n",
    "plot.set_ylabel('accuracy',fontdict={'fontsize':16})\n",
    "\n",
    "plot.axvline(x = 1000, color = 'lightgrey')\n",
    "plot.axvline(x = 2000, color = 'lightgrey')\n",
    "plot.axvline(x = 4000, color = 'lightgrey')\n",
    "plot.axvline(x = 8000, color = 'lightgrey')\n",
    "plot.axvline(x = 16000, color = 'lightgrey')\n",
    "\n",
    "bar_plot = df_pacc.plot(x=\"elapsed_examples\", y=\"planning_accuracy\", \n",
    "                             ax=plot,\n",
    "                             mark_right=False, \n",
    "                             xticks=[1000, 2000, 4000, 8000, 16000])\n",
    "\n",
    "\n",
    "## log base 2 view\n",
    "\n",
    "SMALL_SIZE = 10\n",
    "MEDIUM_SIZE = 14\n",
    "BIGGER_SIZE = 18\n",
    "\n",
    "plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n",
    "plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=MEDIUM_SIZE)    # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=MEDIUM_SIZE)    # fontsize of the tick labels\n",
    "plt.rc('legend', fontsize=MEDIUM_SIZE)    # legend fontsize\n",
    "plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.set_xscale('log', base=2)\n",
    "# ax.set_ylim(0, 1)\n",
    "fig.set_size_inches(16,10)\n",
    "plt.xticks([0, 1000, 2000, 4000, 8000, 16000], ['0', '1000', '2000', '4000', '8000', '16000'])\n",
    "ax.plot(df_append[\"elapsed_examples\"], df_append[\"validation_token_accuracy\"])\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare no macro planning times and length on test set\n",
    "Probe failed plans are ignored.\n",
    "\n",
    "| Test |       Date | Start time | End time |\n",
    "|------|------------|------------|----------|\n",
    "|    1 | 19/02/2023 |   17:22:24 | 21:25:58 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 problems loaded\n",
      "Running Probe tests --- 100%%\n",
      "Starting GPT test at 17:22:24\n",
      "WARNING: the query for problem ./dataset/test/problems/problem_conditional_4_24_00250.pddl has exceed the max_tokens limit.\n",
      "WARNING: the query for problem ./dataset/test/problems/problem_conditional_4_24_00413.pddl has exceed the max_tokens limit.\n",
      "WARNING: the query for problem ./dataset/test/problems/problem_conditional_4_24_00443.pddl has exceed the max_tokens limit.\n",
      "WARNING: the query for problem ./dataset/test/problems/problem_conditional_4_24_00552.pddl has exceed the max_tokens limit.\n",
      "Running Teriyaki tests --- 100%%\n",
      "Finished GPT test at 21:25:58\n",
      "Tests completed\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import subprocess\n",
    "import os\n",
    "import openai\n",
    "import time\n",
    "from tempfile import TemporaryFile\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1900,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/test/problems/'))\n",
    "n_samples = 1000 ## limit number of samples\n",
    "print(\"{0} problems loaded\".format(min(n_samples, len(problems))))\n",
    "\n",
    "results = np.empty([2,6])\n",
    "timings = np.empty([min(n_samples, len(problems)),2])\n",
    "\n",
    "### Test Probe\n",
    "\n",
    "comparison_results = []\n",
    "planning_times = []\n",
    "planning_steps = []\n",
    "fails = 0\n",
    "\n",
    "print(\"Running Probe tests --- 0%\", end = '\\r')\n",
    "for j, problem in enumerate(problems):\n",
    "    if j == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    result = subprocess.run(['./generator/probe', \n",
    "                             '-d', './dataset/domains/domain_m_0.pddl', \n",
    "                             '-i', './dataset/test/problems/' + problem,\n",
    "                             '-o', './dataset/test/plans_no_macro/m_0-' + str(problem.split('_',2)[2:][0])], \n",
    "                             stdout=subprocess.PIPE)\n",
    "\n",
    "    # considering failures plans that took more than 1sec or that failed planning\n",
    "    try:\n",
    "        planning_steps.append(float(result.stdout.decode(\"utf8\").split('steps: ')[1].split('\\n')[0]))\n",
    "        ptime = float(result.stdout.decode(\"utf8\").split('Time: ')[1].split('\\n')[0])\n",
    "        planning_times.append(ptime)\n",
    "\n",
    "    except IndexError:\n",
    "        planning_times.append(np.nan) \n",
    "        fails+=1\n",
    "\n",
    "    print(\"Running Probe tests --- \" + str(round((j / min(n_samples, len(problems)) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "print(\"Running Probe tests --- 100%\")\n",
    "timings[:,0] = planning_times\n",
    "\n",
    "planning_times = np.array(planning_times)\n",
    "planning_steps = np.array(planning_steps)\n",
    "\n",
    "comparison_results.append(np.nanmean(planning_steps))\n",
    "comparison_results.append(np.nanmin(planning_times))\n",
    "comparison_results.append(np.nanmax(planning_times))\n",
    "comparison_results.append(np.nanmean(planning_times))\n",
    "comparison_results.append(np.nanstd(planning_times))\n",
    "\n",
    "comparison_results.append(fails)\n",
    "\n",
    "results[0] = comparison_results\n",
    "\n",
    "### Test Teriyaki\n",
    "\n",
    "comparison_results = []\n",
    "planning_times = []\n",
    "planning_steps = []\n",
    "fails = 0\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%H:%M:%S\", t)\n",
    "print(\"Starting GPT test at \" + current_time)\n",
    "\n",
    "print(\"Running Teriyaki tests --- 0%\", end = '\\r')\n",
    "for j, problem in enumerate(problems):\n",
    "    if j == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    st = time.time()\n",
    "    result = GPT_Plan('./dataset/test/problems/' + problem)\n",
    "    et = time.time()\n",
    "    # considering failures plans that took more than 1sec or that failed planning\n",
    "    try:\n",
    "        planning_steps.append(float(result.count('\\n')))\n",
    "        planning_times.append(et - st)\n",
    "\n",
    "    except IndexError:\n",
    "        planning_times.append(np.nan) \n",
    "        fails+=1\n",
    "\n",
    "    print(\"Running Teriyaki tests --- \" + str(round((j / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "print(\"Running Teriyaki tests --- 100%\")\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%H:%M:%S\", t)\n",
    "print(\"Finished GPT test at \" + current_time)\n",
    "\n",
    "timings[:,1] = planning_times\n",
    "\n",
    "planning_times = np.array(planning_times)\n",
    "planning_steps = np.array(planning_steps)\n",
    "\n",
    "comparison_results.append(np.nanmean(planning_steps))\n",
    "comparison_results.append(np.nanmin(planning_times))\n",
    "comparison_results.append(np.nanmax(planning_times))\n",
    "comparison_results.append(np.nanmean(planning_times))\n",
    "comparison_results.append(np.nanstd(planning_times))\n",
    "\n",
    "comparison_results.append(fails)\n",
    "\n",
    "results[1] = comparison_results\n",
    "\n",
    "with open('./timings/results_no_macro.npy', 'wb') as f:\n",
    "    np.save(f, results)\n",
    "    \n",
    "with open('./timings/timings_no_macro.npy', 'wb') as f:\n",
    "    np.save(f, timings)\n",
    "    \n",
    "print(\"Tests completed\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results table "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_b4041\" style=\"font-size: 20px\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_b4041_level0_col0\" class=\"col_heading level0 col0\" >SOLVER</th>\n",
       "      <th id=\"T_b4041_level0_col1\" class=\"col_heading level0 col1\" >avg_steps</th>\n",
       "      <th id=\"T_b4041_level0_col2\" class=\"col_heading level0 col2\" >min</th>\n",
       "      <th id=\"T_b4041_level0_col3\" class=\"col_heading level0 col3\" >max</th>\n",
       "      <th id=\"T_b4041_level0_col4\" class=\"col_heading level0 col4\" >avg</th>\n",
       "      <th id=\"T_b4041_level0_col5\" class=\"col_heading level0 col5\" >std</th>\n",
       "      <th id=\"T_b4041_level0_col6\" class=\"col_heading level0 col6\" >fails</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_b4041_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_b4041_row0_col0\" class=\"data row0 col0\" >Probe</td>\n",
       "      <td id=\"T_b4041_row0_col1\" class=\"data row0 col1\" >22.137</td>\n",
       "      <td id=\"T_b4041_row0_col2\" class=\"data row0 col2\" >0.006</td>\n",
       "      <td id=\"T_b4041_row0_col3\" class=\"data row0 col3\" >43.768</td>\n",
       "      <td id=\"T_b4041_row0_col4\" class=\"data row0 col4\" >2.788</td>\n",
       "      <td id=\"T_b4041_row0_col5\" class=\"data row0 col5\" >3.303</td>\n",
       "      <td id=\"T_b4041_row0_col6\" class=\"data row0 col6\" >17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_b4041_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "      <td id=\"T_b4041_row1_col0\" class=\"data row1 col0\" >Teiryaki</td>\n",
       "      <td id=\"T_b4041_row1_col1\" class=\"data row1 col1\" >19.158</td>\n",
       "      <td id=\"T_b4041_row1_col2\" class=\"data row1 col2\" >0.440</td>\n",
       "      <td id=\"T_b4041_row1_col3\" class=\"data row1 col3\" >54.705</td>\n",
       "      <td id=\"T_b4041_row1_col4\" class=\"data row1 col4\" >14.614</td>\n",
       "      <td id=\"T_b4041_row1_col5\" class=\"data row1 col5\" >7.163</td>\n",
       "      <td id=\"T_b4041_row1_col6\" class=\"data row1 col6\" >0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f7d76d72d30>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "results = np.load('./timings/results_no_macro.npy')\n",
    "\n",
    "results_table = pd.DataFrame(results, columns=('avg_steps', 'min', 'max', 'avg', 'std', 'fails'))\n",
    "\n",
    "df = pd.DataFrame({'SOLVER': ('Probe', 'Teiryaki')})\n",
    "df = pd.concat([df, results_table],axis=1)\n",
    "df = df.astype({\"fails\":\"int\"})\n",
    "\n",
    "df.style.\\\n",
    "    format(precision=3).\\\n",
    "    set_table_attributes('style=\"font-size: 20px\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results boxplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7kAAAIYCAYAAACokCs/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlPklEQVR4nO3de7htd13f+8+XbCQm1mDjNhRbSEAIVitQNscQPFySIwWRgBIEWhAtEIRSDBAeLxCzo3COR1O5GiBIG4G2wYaLUjHYmnCNQgOmlCpECOFmEnaISYQAmvDtH3MsWCzW2ll7Z8815/rt1+t51jPWHHOMOb87/8y81xhzjOruAAAAwAhus+gBAAAA4EARuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwjLlHblX9/1X1J1X1mar6clVdW1V/XlVnVNWRG+xzfFW9fdr2y1X14ao6taoOmfe8AAAAbF/V3fN9g6q/S/KhJH+R5PNJDk9yXJJdSf46yXHd/ZlV2z8yyZuSfCXJG5Ncm+QRSY5Ncn53P2auAwMAALBtbUXkHtrdX1ln/YuS/HKSV3b3M6Z135nk40mOSHL/7r5k5TWSXJjkfkke393nzXVoAAAAtqW5n668XuBOfm9a3m3VupOT7Exy3krgrnqNF0wPn37AhwQAAGAIi7zw1COm5YdXrTthWl6wzvbvTnJjkuOr6nbzHAwAAIDtacdWvVFVnZbkOzI7FXlXkh/JLHB/fdVmx07Ly9bu3903VdUnk/xAkrsk+cu5DgwAAMC2s2WRm+S0JEetenxBkp/p7j2r1h0xLa/f4DVW1t9+vSer6pQkpyTJ4Ycffp973OMe+z0sAAAAy+uDH/zgNd29c+36LYvc7r5DklTVUUmOz+wI7p9X1Y9394cO0Huck+ScJNm1a1dfcsklt7AHAAAA21FVfWq99Vv+ndzuvrq735LkIUmOTPK6VU+vHKk94lt2/Ob1181nOgAAALazhV14qrs/ldm9c3+gqr57Wv2xaXn3tdtX1Y4kxyS5KcnlWzIkAAAA28oir66cJHecljdPywun5UPX2fYBSQ5LcnF3f3XegwEAALD9zDVyq+ruVfUtpx5X1W2q6kVJviezaP2b6anzk1yT5HFVtWvV9ocmeeH08JXznBkAAIDta94XnvqxJP9fVb03ySeTfCGzKyw/MLPbAF2V5KkrG3f3DVX11Mxi951VdV6Sa5OclNnthc5P8sY5zwwAAMA2Ne/I/e9Jvi+ze+LeO7Nb/3wps/vgvj7Jy7r72tU7dPdbq+qBSZ6f5NFJDk3y8STPmbbvOc8MAADANjXXyO3ujyR55n7s977MjgIDAADApi36wlMAAABwwIhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYexY9AAAALAoZ5555qJHSJKcccYZix4BhiFyAQA4aN3auKw6K92nHaBpgAPB6coAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDmGvkVtWRVfWUqnpLVX28qr5cVddX1Xur6slVdZs12x9dVb2Xn/PmOS8AAADb2445v/5jkrwyyZVJLkry6SRHJfnJJL+T5GFV9Zju7jX7/c8kb13n9T4yv1EBAADY7uYduZclOSnJH3b311ZWVtUvJ/lAkkdnFrxvWrPfpd29e86zAQAAMJi5nq7c3Rd299tWB+60/qokr5oePmieMwAAAHDwmPeR3L35+2l50zrP3bGqnpbkyCRfSPKn3f3hLZsMAACAbWkhkVtVO5L89PTwgnU2+dHpZ/U+70zypO7+9HynAwAAYLta1C2Efj3JDyZ5e3e/Y9X6G5P8WpL7JPmu6eeBmV206kFJ/qSqDt/oRavqlKq6pKou2bNnz7xmBwAAYElteeRW1bOSPDfJR5M8cfVz3f357v6V7v5Qd183/bw7yUOSvD/J9yV5ykav3d3ndPeu7t61c+fOOf4rAAAAWEZbGrlV9cwkL03yF0ke3N3Xbma/7r4ps1sOJckD5jQeAAAA29yWRW5VnZrk5Znd6/bB0xWW98XK+ccbnq4MAADAwW1LIreqfiHJi5Ncmlngfn4/Xua4aXn5gZoLAACAscw9cqvq9MwuNPXBJCd29zV72fafV9W3zFRVJyZ59vTwDXMZFAAAgG1vrrcQqqonJfnVJDcneU+SZ1XV2s2u6O5zp99/K8ndquriJJ+d1v1QkhOm30/v7ovnOTMAAADb17zvk3vMtDwkyakbbPOuJOdOv78+yU8kuW+ShyW5bZKrk/xekld093vmNSgAAADb31wjt7t3J9m9D9u/Nslr5zUPAAAAY9vy++QCAADAvIhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGMZcI7eqjqyqp1TVW6rq41X15aq6vqreW1VPrqp137+qjq+qt1fVtdM+H66qU6vqkHnOCwAAwPa2Y86v/5gkr0xyZZKLknw6yVFJfjLJ7yR5WFU9prt7ZYeqemSSNyX5SpI3Jrk2ySOSvDjJ/afXBAAAgG8x78i9LMlJSf6wu7+2srKqfjnJB5I8OrPgfdO0/juTvCbJzUke1N2XTOtPT3JhkpOr6nHdfd6c5wYAAGAbmuvpyt19YXe/bXXgTuuvSvKq6eGDVj11cpKdSc5bCdxp+68kecH08OnzmxgAAIDtbJEXnvr7aXnTqnUnTMsL1tn+3UluTHJ8Vd1unoMBAACwPS0kcqtqR5Kfnh6uDtpjp+Vla/fp7puSfDKzU6zvMtcBAQAA2JYWdST315P8YJK3d/c7Vq0/Ylpev8F+K+tvv96TVXVKVV1SVZfs2bPngAwKAADA9rHlkVtVz0ry3CQfTfLEA/na3X1Od+/q7l07d+48kC8NAADANrClkVtVz0zy0iR/keTB3X3tmk1WjtQekfWtrL/uwE8HAADAdrdlkVtVpyZ5eZKPZBa4V62z2cem5d3X2X9HkmMyu1DV5XMaEwAAgG1sSyK3qn4hyYuTXJpZ4H5+g00vnJYPXee5ByQ5LMnF3f3VAz4kAAAA297cI7eqTs/sQlMfTHJid1+zl83PT3JNksdV1a5Vr3FokhdOD185r1kBAADY3nbM88Wr6klJfjXJzUnek+RZVbV2syu6+9wk6e4bquqpmcXuO6vqvCTXJjkps9sLnZ/kjfOcGQAAgO1rrpGb2Xdok+SQJKdusM27kpy78qC731pVD0zy/CSPTnJoko8neU6Sl3V3z2tYAAAAtre5Rm53706yez/2e1+SHzvQ8wAAADC2Lb9PLgAAAMyLyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGDsWPQAAAOyPO9zh7Fx99Y2LHiNVZy16hBx11GG56qpnLHoMWAqO5AIAsC0tQ+AuC/8t4BtELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADD2FTkVtXhVXWb6fe7V9VJVXXb+Y4GAAAA+2azR3LfneTQqvreJH+c5IlJzt3MjlV1clW9vKreU1U3VFVX1Rs22Pbo6fmNfs7b5LwAAAAchHZscrvq7hur6slJzu7u36iqSze57wuS3DPJF5N8Nsk9NrHP/0zy1nXWf2ST7wkAAMBBaNORW1X3S/Kvkjx5WnfIJvd9dmZx+/EkD0xy0Sb2ubS7d2/y9QEAACDJ5iP31CS/lOQt3f2/q+ou2Vyspru/vl1V7fOAAAAAsFmbitzufleSd616fHmSZ81rqCR3rKqnJTkyyReS/Gl3f3iO7wcAAMAA9hq5VfW2JL3R89190gGfaOZHp5/Vs7wzyZO6+9Nzek8AAAC2uVu6uvJZSf5dkk8m+XKS10w/X0zyiTnMc2OSX0tynyTfNf2sfI/3QUn+pKoOn8P7AgAAMIC9HsmdTlNOVf277t616qm3VdUlB3qY7v58kl9Zs/rdVfWQJO9N8sNJnpLkpevtX1WnJDklSe50pzsd6PEAAABYcpu9T+7h08WmkiRVdUySLTui2t03Jfmd6eED9rLdOd29q7t37dy5c2uGAwAAYGls9urKz07yzqq6PEkluXOSp81tqvXtmZZOVwYAAGBdm7268gVVdbck95hWfbS7vzq/sdZ13LS8fIvfFwAAgG1is0dyk9nFoI6e9rlnVaW7X3cgh6mqf57k0u7+2pr1J2Z2NDlJ3nAg3xMAAIBxbCpyq+r1Se6a5NIkN0+rO8ktRm5VPSrJo6aHd5iW96uqc6ffr+nu06bffyvJ3arq4iSfndb9UJITpt9P7+6LNzMzAAAAB5/NHsndleSfdveG98zdi3sledKadXeZfpLkU0lWIvf1SX4iyX2TPCzJbZNcneT3kryiu9+zH+8PAADAQWKzkfuRzI7CXrmvb9Ddu5Ps3uS2r03y2n19DwAAAEg2H7nfneQvquoDSb5+wanuPmkuUwEAAMB+2Gzk7p7nEAAAAHAgbPYWQu+qqqMy+65sknyguz8/v7EAAABg391mMxtV1U8l+UCSxyT5qSTvr6qT5zkYAAAA7KvNnq78/CT3XTl6W1U7k/z3JOfPazAAAADYV5s6kpvkNmtOT/7CPuwLAAAAW2KzR3IvqKp3JPnP0+PHJvmj+YwEAAAA+2ezF556XlX9ZJIfmVad091vmd9YAAAAsO82FblVdUySt3f3m6fH315VR3f3FfMcDgAAAPbFZr9X+1+SfG3V45undQAAALA0Nhu5O7r771YeTL9/23xGAgAAgP2z2cjdU1UnrTyoqkcmuWY+IwEAAMD+2ezVlX8uyX+sqt9O0kk+m+Sn5zYVAAAA7IfNXl35E0mOq6rvmB5/ca5TAQAAwH7Y1OnKVXVUVb02yX/p7i9W1T+tqifPeTYAAADYJ5v9Tu65Sd6R5I7T48uSnDqHeQAAAGC/bTZyv7u7fy/TbYS6+6bMbiMEAAAAS2Ozkfulqjoys4tOpaqOS3L93KYCAACA/bDZqys/J8kfJLlrVb0vyc4kJ89tKgAAANgPmz2Se9ckD0tyfGbfzf2rbD6QAQAAYEtsNnJP7+4bknxXkgcnOTvJK+c2FQAAAOyHzUbuykWmHp7kNd39h0m+bT4jAQAAwP7ZbOR+rqpeneSxSd5eVbfbh30BAABgS2w2VH8qs+/i/ovuvi7JP0zyvHkNBQAAAPtjUxeP6u4bk7x51eMrk1w5r6EAAOCWdDvm8s1OW/QAsBRcIRkAgG2p6jcXPcJS6V70BLAcfK8WAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYcw1cqvq5Kp6eVW9p6puqKquqjfcwj7HV9Xbq+raqvpyVX24qk6tqkPmOSsAAADb3445v/4LktwzyReTfDbJPfa2cVU9MsmbknwlyRuTXJvkEUlenOT+SR4zz2EBAADY3uZ9uvKzk9w9yXcmefreNqyq70zymiQ3J3lQdz+5u5+X5F5J/jTJyVX1uPmOCwAAwHY218jt7ou6+6+6uzex+clJdiY5r7svWfUaX8nsiHByC6EMAADAwW2ZLjx1wrS8YJ3n3p3kxiTHV9Xttm4kAAAAtpNlitxjp+Vla5/o7puSfDKz7xDfZSuHAgAAYPtYpsg9Ylpev8HzK+tvv9ELVNUpVXVJVV2yZ8+eAzkbAABL5qijDlv0CEvDfwv4hnlfXXlLdfc5Sc5Jkl27dm3me8AAAGxTV131jEWPkKqz0n3aoscAVlmmI7krR2qP2OD5lfXXzX8UAAAAtqNlityPTcu7r32iqnYkOSbJTUku38qhAAAA2D6WKXIvnJYPXee5ByQ5LMnF3f3VrRsJAACA7WSZIvf8JNckeVxV7VpZWVWHJnnh9PCVixgMAACA7WGuF56qqkcledT08A7T8n5Vde70+zU9fVO/u2+oqqdmFrvvrKrzklyb5KTMbi90fpI3znNeAAAAtrd5X135XkmetGbdXfKNe91+KsnXL0fX3W+tqgcmeX6SRyc5NMnHkzwnycu62xWTAQAA2NBcI7e7dyfZvY/7vC/Jj81jHgAAAMa2TN/JBQAAgFtF5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDB2LHoAYHmceeaZix7h684444xFjwAAwDYkcoGvOxBhWXVWuk87ANMAAMC+c7oyAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADGMpI7eqrqiq3uDnqkXPBwAAwHLasegB9uL6JC9ZZ/0Xt3gOAAAAtolljtzrunv3oocAAABg+1jK05UBAABgfyzzkdzbVdUTktwpyZeSfDjJu7v75sWOBQAAwLJa5si9Q5LXr1n3yar62e5+1yIGAgAAYLkt6+nK/yHJiZmF7uFJ/lmSVyc5OskfVdU919upqk6pqkuq6pI9e/Zs1awAAAAsiaWM3O4+s7sv7O6ru/vG7v5Id/9ckt9K8u1Jdm+w3zndvau7d+3cuXMrRwYAAGAJLGXk7sWrpuUDFjoFAAAAS2m7Re7KOciHL3QKAAAAltJ2i9zjpuXlC50CAACApbR0kVtV319V33KktqqOTvKK6eEbtnQoAAAAtoVlvIXQY5M8t6reneRTSf42yV2TPDzJoUnenuSsxY0HAADAslrGyL0oybFJ7p3k/pl9//a6JO/N7L65r+/uXth0AAAALK2li9zufleSdy16DgAAALafpftOLgAAAOwvkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwdix6AODAucMdzs7VV9+46DFSddaiR8hRRx2Wq656xqLHAABgizmSCwNZhsBdFv5bAAAcnEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADEPkAgAAMAyRCwAAwDBELgAAAMMQuQAAAAxD5AIAADAMkQsAAMAwRC4AAADDELkAAAAMQ+QCAAAwDJELAADAMEQuAAAAwxC5AAAADGPHogcADpzu5y16hCVz2qIHAABgi4lcGEjVby56hKXSvegJAADYak5XBgAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyIWBHHXUYYseYWn4bwEAcHDasegBgAPnqquesegRUnVWuk9b9BgAABykljJyq+ofJ/nVJA9NcmSSK5O8NcmZ3f03CxwNAICBnHnmmbdq/927b/1rJMkZZ5xxq18DmFm6yK2quya5OMn3JPn9JB9N8n8l+fkkD62q+3f3FxY4IgAAgxCXMJ5l/E7u2ZkF7rO6+1Hd/YvdfUKSFyc5NsmLFjodAAAAS2upInc6ivuQJFck+e01T5+R5EtJnlhVh2/xaAAAAGwDSxW5SR48Lf+4u7+2+onu/tsk70tyWJLjtnowAAAAlt+yRe6x0/KyDZ7/q2l59y2YBQAAgG1m2SL3iGl5/QbPr6y//fxHAQAAYLtZuqsr3xpVdUqSU5LkTne604Knge3nQNwCwa0UAABYpGWL3JUjtUds8PzK+uvWe7K7z0lyTpLs2rWrD+hkcBAQlgAAbHfLdrryx6blRt+5vdu03Og7uwAAABzEli1yL5qWD6mqb5qtqv5BkvsnuTHJn231YAAAACy/pYrc7v5Ekj9OcnSSf7Pm6TOTHJ7k9d39pS0eDQAAgG1g2b6TmyTPSHJxkpdV1YlJ/jLJD2d2D93Lkjx/gbMBAACwxJbqSG7y9aO5u5Kcm1ncPjfJXZO8NMlx3f2FxU0HAADAMlvGI7np7s8k+dlFzwEAAMD2snRHcgEAAGB/iVwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGIbIBQAAYBgiFwAAgGGIXAAAAIYhcgEAABiGyAUAAGAYIhcAAIBhiFwAAACGUd296Bnmoqr2JPnUoueAg9B3J7lm0UMAwBbxuQeLc+fu3rl25bCRCyxGVV3S3bsWPQcAbAWfe7B8nK4MAADAMEQuAAAAwxC5wIF2zqIHAIAt5HMPlozv5AIAADAMR3IBAAAYhsgF5q6qfqaquqp+ZtGzAMC+WtTnWFWdO73v0ZvcvqvqnfOdCpafyIWDxPTBt/rn5qq6pqourKp/uej5AGBv1vkcu6Wfn1n0zMBi7Fj0AMCWO3Na3jbJPZI8MsmDq2pXdz9ncWMBwF6duc66U5MckeSlSa5b89ylB/C935Lkz5JceQBfcx6+P8mNix4CFk3kwkGmu3evflxVJyb5b0lOraqXdfcVi5gLAPZm7edXMjuNOLPIfck8P7+6+/ok18/r9Q+U7v7oomeAZeB0ZTjIdfefJPlokkpy3ySpqt3TqV4Pqqp/WVXvr6ovVtUVK/tV1T+qqt+uqiuq6u+qak9Vvbmq7rO396uqh1fVxVX1par6m6o6v6rutsG2h1XVL1XVpdP2X6yqP62qxx+4/wIAjKiqfnj6jLlq+pz6TFW9uqruuM6275w+976tqn6lqj5WVV+tqnOn57/pO7lVdcj0ejdU1Xds8P4vn/Y5edW6R1XVG6rqsulz7UtV9cGqelZVbfr/y6vqnlX1uen9f3TVet/JhTiSC8zUtFx7T7HnJvnRJG9LclFmfy1PVR2T5L1J7pjkwiT/Ock/SfKYJA+vqkd3939d531+MsnDMjvt651J7pXk0ZmdLn18d3/s6wNV3X567Xsn+VCSf5/ZH+b+RZL/VFU/0N0vuDX/aADGVFX/OrP71341yR8k+UySuyV5SpJHVNVx3f3pdXZ9U2Z/8P2jJG9N8vn1Xr+7b66q12R2CvXjk7xmzft/e5InJLkqye+veurXk3wtyfuTfC6zz9UTMjvd+r5JnriJf9uJSd6c5EtJHtDdl97SPnCwEblwkKuq/yfJsZkF7v9Y8/QJSe7X3X++Zv2rMgvcF3T3i1a91tlJ3p3kd6vqzt39xTX7PSLJI1YHcFX9fJKXJDk7yYmrtn1JZoH7C939G6u2PzSz//H45ao634c7AKtV1d0z+5y6IskDu/tzq547MckfZxaVP7HO7ndO8oPdfc0m3uo1SU5P8rSsidwkj01y+yT/b3f//ar1D+/uT6yZ9zZJ/kOSn66qV3T3+/fyb3tCZn/0/XiSh3X3pzYxJxx0nK4MB5npVOTdVfWiqjo/yQWZHcl9yTofluesDdyq+sdJHpLk00l+Y/Vz3X1xZkd1/2FmR23XunCdI7yvSPKJJCdU1Z2n9zgys7+AX7I6cKf3+EqSX5hmdlVoANZ6emYXV/z51YGbfP0rOn+Q2dHcf7DOvqdvMnDT3Vdm9kfX+6zzVZ2nZXbE9jVr9vnEmu3S3V/LLLqT2dlK66qqX0zyusyOAt9f4MLGHMmFg88Z07IzuxLle5K8trvfsM62H1hn3b2n5XvW/HV6xYWZBeq9M/swXu1dazeeTvl6b5K7Tvt8KrNTtg5J0lW1e533uO20/P51ngPg4Ha/afnAqrrvOs9/T2afMXdP8sE1z633ubc3Zyc5ObOoPSVJquqfJTkuyR+tvRjW9Efc5yX5sSR3SXL4mtf73g3e58VJHpXZ6dRPmP7gC2xA5MJBprvrlrf6uqvWWXfEtNzoNgor62+/znNX38L7rLz2kdPyvtPPRta92AcAB7WVz5Dn3cJ2632GrPe5t6Huvqiq/jLJ46vqud39t5liN8mrV287XWvifyQ5JrOYfl2Sa5PclNln5s8nud0Gb/WAaflfBS7cMpEL7M3aC1El37iFwh022OcfrdlutaM22Gflta5fs3yxe/cCsI9WPkOO6O4b9mXH7l7vc++WvCqz043/VVX9bmZnM30uydqv5zwls8A9c53b+d0vs8jdyKMy+y7ua6vqtt299jvAwCq+kwvsq5Xv6P5IVa33h7IHT8sPrfPcA9euqKpDkvzImtf+QGbfZfq/b8WcAByc/mxabtVnyO8muTGzI7grF5x6bXffvGa775uWb1rnNb7l83GNz2R2NPdjSV5dVf9mv6eFg4DIBfZJd382yX9LcnSSU1c/V1U/nNnFoP4ms9sErXVCVf34mnXPzOz7uBetXESjuz+f5D8m2VVVp08h/E2q6q7TrYwAYLVXJPn7JC+errT8TaZ74R6wAO7u65P8p8yuK/HCJDfnW6+2nMyu9pwkD1ozz72T/NIm3ufKzGL4fyV5RVU9d7+HhsE5XRnYHz+X5H1JfrOqHpLkknzjPrlfS/Kz0/eS1npbkrdU1Vsyu/3BvTK7b+61SZ6xZttnZnZPw19N8sTp4lRXZ3brou/P7Lu6j0/yyQP6LwNgW+vuj073yf33Sf53VV2Q5LLMLlp4p8yO8O5Jco8D+LZnZ3Y68vcmedv0B+G1XpfZ94RfUlUPTvJXmX3O/Xhm97197C29SXfvmfZ9R5KzqurQ1bfyA2YcyQX2WXdfnmRXZt9DOjbJaZnF6gWZ3dbg9zfY9c2Z3Zfwn2T23aPjp3X36+6PrnmPGzL7i/W/TXJNkkcneU5mp0P/bZJnZ3ZEGQC+yXTHgPtkdlbQD2X2h9MnZHbK8Pn51j+s3tr3+/Mkl04PX73BNn+dWWD/YWZf03lmZvflfUaSX9yH97o2s/vKX5zkhVX1a/s9OAyq9u/79QAAQJJM99z968zOTDpmuvctsCCO5AIAwK3z9MxuSXS2wIXFcyQXAAD2UVUdkVncfm+Sp2Z2FPfYDa5JAWwhkQsAAPuoqo7O7OKHX03ywST/trvXu30esMVELgAAAMPwnVwAAACGIXIBAAAYhsgFAABgGCIXAACAYYhcAAAAhiFyAQAAGMb/Aa2xSFUOuz9KAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "timings = np.load('./timings/timings_no_macro.npy')\n",
    "\n",
    "dft = pd.DataFrame(timings, columns=['Probe','Teriyaki'])\n",
    "\n",
    "props = dict(boxes=\"DarkBlue\", \n",
    "             whiskers=\"DarkBlue\", \n",
    "             medians=\"Yellow\", \n",
    "             caps=\"Gray\")\n",
    "\n",
    "boxplot = dft.plot.box(figsize=(16,9), \n",
    "                       fontsize=20, \n",
    "                       color=props, \n",
    "                       patch_artist=True,\n",
    "                       xlabel=\"Solver\",\n",
    "                       ylabel=\"seconds\",\n",
    "                       showfliers=False)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fine-tuning Teriyaki for dual domain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -r dataset/batches/dual &> /dev/null\n",
    "!rm -r dataset/batches/validation/dual &> /dev/null\n",
    "!rm -r dataset/batches/validation/results/dual\n",
    "!mkdir dataset/batches/dual/\n",
    "!mkdir dataset/batches/dual/problems\n",
    "!mkdir dataset/batches/dual/plans\n",
    "!mkdir dataset/batches/dual/plans_ipc\n",
    "!mkdir dataset/batches/validation/results/dual\n",
    "!mkdir dataset/batches/validation/results/dual/plans\n",
    "!mkdir dataset/batches/validation/results/dual/val\n",
    "!mkdir dataset/batches/validation/dual\n",
    "!mkdir dataset/batches/validation/dual/plans\n",
    "!mkdir dataset/batches/validation/dual/problems\n",
    "\n",
    "import os\n",
    "import subprocess\n",
    "import shutil\n",
    "import openai\n",
    "import requests\n",
    "import random\n",
    "\n",
    "## generate problems\n",
    "\n",
    "%run generator/pddl_confgen.py 4 1200 -r 24 -co\n",
    "!mv -v generator/problems/conditional/* dataset/batches/dual/problems > /dev/null\n",
    "\n",
    "## generate plans\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/batches/dual/problems'))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    if i < (len(problem)/2):\n",
    "        result = subprocess.run(['./generator/probe', \n",
    "                                 '-d', './dataset/domains/domain_m_0.pddl', \n",
    "                                 '-i', './dataset/batches/dual/problems/' + problem,\n",
    "                                 '-o', './dataset/batches/dual/plans/m_0-' + str(problem.split('_',2)[2:][0])], \n",
    "                                 stdout=subprocess.PIPE)\n",
    "        print(\"Planning --- \" + str(round((i / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "    if i >= (len(problem)/2):\n",
    "        result = subprocess.run(['./generator/probe', \n",
    "                                 '-d', './dataset/domains/domain_m_25_B.pddl', \n",
    "                                 '-i', './dataset/batches/dual/problems/' + problem,\n",
    "                                 '-o', './dataset/batches/dual/plans/m_25_B-' + str(problem.split('_',2)[2:][0])], \n",
    "                                 stdout=subprocess.PIPE)\n",
    "        print(\"Planning --- \" + str(round((i / len(problems) * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "## convert to IPC    \n",
    "    \n",
    "plans = sorted(os.listdir('./dataset/batches/dual/plans/'))\n",
    "\n",
    "for plan in plans:\n",
    "    probe = open('./dataset/batches/dual/plans/' + plan, \"r\")\n",
    "    val = open('./dataset/batches/dual/plans_ipc/' + plan.split(\".\")[0] + \".plan\", 'w+')\n",
    "    replacement = \"\"\n",
    "    # using the for loop\n",
    "    action_timing = 1\n",
    "    for line in probe:\n",
    "        line = line.lower()\n",
    "        line = '%.3f' % (action_timing / 1000) + \"00: \" + line\n",
    "        val.write(line)\n",
    "        action_timing += 2\n",
    "\n",
    "    probe.close()\n",
    "    val.close()\n",
    "    \n",
    "print(\"Plans converted to IPC format\")\n",
    "\n",
    "## sort plans\n",
    "## Uncomment only if you need to generate a validation dataset\n",
    "\n",
    "plans_ipc = sorted(os.listdir('./dataset/batches/dual/plans_ipc/'))\n",
    "\n",
    "for i, plan in enumerate(plans_ipc):\n",
    "    if i < 1000:\n",
    "        continue\n",
    "    else:\n",
    "        shutil.move('./dataset/batches/dual/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \n",
    "                     'dataset/batches/validation/dual/problems/')\n",
    "        shutil.move('./dataset/batches/dual/plans_ipc/' + plans_ipc[i], 'dataset/batches/validation/dual/plans/')\n",
    "\n",
    "print('All problems and plans have been sorted into batches.')\n",
    "\n",
    "# compile datasets\n",
    "\n",
    "dataset = open('./dataset/batches/dual/teriyaki_dual.jsonl', 'w+')\n",
    "plans_ipc = sorted(os.listdir('./dataset/batches/dual/plans_ipc/'))\n",
    "\n",
    "for i, plan in enumerate(plans_ipc):\n",
    "    plan_f = open('./dataset/batches/dual/plans_ipc/' + plan, \"r\")\n",
    "    problem_f = open('./dataset/batches/dual/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \"r\")\n",
    "    lines = problem_f.readlines()\n",
    "    if \"m_25_B\" in plan:\n",
    "        dataset.write(repr('{\"prompt\":\"\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + \n",
    "              '\\n\\n###\\n\\n\", \"completion\":\" ' + plan_f.read().replace(\"    \", \"\") + ' END\"}')[1:-1] + \"\\n\")\n",
    "    else:\n",
    "        dataset.write(repr('{\"prompt\":\"\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + \n",
    "              '\\n\\n###\\n\\n\", \"completion\":\" ' + plan_f.read().replace(\"    \", \"\") + ' END\"}')[1:-1] + \"\\n\")\n",
    "\n",
    "dataset.close()\n",
    "\n",
    "lines = open(dataset).readlines()\n",
    "random.shuffle(lines)\n",
    "open(dataset, 'w').writelines(lines)\n",
    "\n",
    "dataset = open('./dataset/batches/validation/dual/teriyaki_dual.jsonl', 'w+')\n",
    "plans_ipc = sorted(os.listdir('./dataset/batches/validation/dual/plans/'))\n",
    "\n",
    "for i, plan in enumerate(plans_ipc):\n",
    "    plan_f = open('./dataset/batches/validation/dual/plans/' + plan, \"r\")\n",
    "    problem_f = open('./dataset/batches/validation/dual/problems/problem_conditional_' + plan.split(\"-\")[1].split(\".\")[0] + \".pddl\", \"r\")\n",
    "    lines = problem_f.readlines()\n",
    "\n",
    "    dataset.write(repr('{\"prompt\":\"\\n--NO-MACRO\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + \n",
    "              '\\n\\n###\\n\\n\", \"completion\":\" ' + plan_f.read().replace(\"    \", \"\") + ' END\"}')[1:-1] + \"\\n\")\n",
    "\n",
    "dataset.close()\n",
    "\n",
    "lines = open(dataset).readlines()\n",
    "random.shuffle(lines)\n",
    "open(dataset, 'w').writelines(lines)\n",
    "\n",
    "print(\"Datasets ready!\")\n",
    "print(\"Before training, run in a terminal\\n\\t>openai tools fine_tunes.prepare_data -f './dataset/batches/[YOUR_BATCH]/teriyaki.jsonl'\")\n",
    "\n",
    "# fine-tune starting from previous model\n",
    "\n",
    "# !openai -k [YOUR_API_KEY] \\\n",
    "# api fine_tunes.create -t './dataset/batches/dual/teriyaki_dual.jsonl' \\\n",
    "# -v './dataset/batches/validation/dual/teriyaki_dual.jsonl' \\\n",
    "# -m 'davinci' --suffix \"teriyaki-003\" --n_epochs 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Teriyaki dual domain accuracy on test set\n",
    "Running tests designed for Teriyaki against Teriyaki no macro.\n",
    "\n",
    "As discussed in the paper, this is not working. Multiple domain planning might require training using examples from both domains.\n",
    "\n",
    "### Learning from Teriyaki-004\n",
    "\n",
    "| Training set size | Job ID | Model ID | Accuracy |\n",
    "|-------------------|---------------------------|------------------------------------------------------|-------|\n",
    "| No macro - 2000 | ft-ZdKuOAYYbedWMPvw0Pm2EV8c | davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07 | 94,0% |\n",
    "|                 |                             | **Probe planner**                                    | 98,6% |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating --- 100.0% --- Current success rate 2.0%\n",
      "Teiyaki failed 98 plans\n",
      "[]\n",
      "nan\n",
      "Validation complete!!\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import openai\n",
    "import subprocess\n",
    "import numpy as np\n",
    "\n",
    "# Uncomment only if you need to generate a new test set\n",
    "# %run generator/pddl_confgen.py 4 1000 -r 24 -co\n",
    "# !mv -v generator/problems/conditional/* dataset/test/problems > /dev/null\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan(problem_path):## Call the API key under your account (in a secure way)\n",
    "    problem_f = open(problem_path)\n",
    "    lines = problem_f.readlines()\n",
    "    problem_query = '\\n(:init\\n' + ''.join(lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "    problem_f.close()\n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-002-2023-02-07-19-44-07\",\n",
    "                                        prompt =  problem_query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1800,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # best_of = 4, # 3-5 work well for code completion\n",
    "                                        stop = \"END\")\n",
    "    \n",
    "    if response.choices[0].finish_reason == \"length\":\n",
    "        print(\"WARNING: the query for problem \" + problem_path + \" has exceed the max_tokens limit.\")\n",
    "    return response.choices[0].text\n",
    "\n",
    "n_samples = 100\n",
    "planning_steps = []\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/test/problems/'))\n",
    "\n",
    "# Teriyaki planning\n",
    "\n",
    "print(\"Planning {0} problems with Teriyaki.\".format(min(n_samples, len(problems))))\n",
    "\n",
    "for i, problem in enumerate(problems):\n",
    "    if i == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)), end = '\\r')\n",
    "    problem_path = './dataset/test/problems/' + problem\n",
    "    plan = GPT_Plan(problem_path)\n",
    "    planning_steps.append(float(plan.count('\\n')))\n",
    "    plan_f = open('./dataset/test/crosstest/{0}'.format(problem)[:-5] + \".plan\", 'w+')\n",
    "    plan_f.write(plan[1:])\n",
    "    plan_f.close()\n",
    "print(\"GPT-Planning --- {0}%\".format(round((i / len(problems) * 100), 1)))\n",
    "\n",
    "# Validate with VAL\n",
    "\n",
    "print(\"Starting VAL validation on the generated dataset.\")\n",
    "invalid_plans = 0\n",
    "success = 0\n",
    "for i, problem in enumerate(problems):\n",
    "    if i == n_samples: ## limit number of iterations\n",
    "            break\n",
    "    if i > 0:\n",
    "        print(\"Validating --- {0}% --- Current success rate {1}%\".format(\n",
    "            round((i / min(n_samples, len(problems)) * 100), 1),\n",
    "            round((success / i * 100), 1)), end = '\\r')\n",
    "    result_f = open('./dataset/test/val/' + problem, 'w+')\n",
    "    result = subprocess.run(['./generator/Validate', \n",
    "                             './dataset/domains/domain_m_25_B.pddl', \n",
    "                             './dataset/test/problems/' + problem,\n",
    "                             './dataset/test/crosstest/{0}'.format(problem)[:-5] + \".plan\"], \n",
    "                             stdout=subprocess.PIPE)\n",
    "    result_f.write(str(result))\n",
    "    result_f.close()\n",
    "    if (\"Plan failed to execute\" in str(result)) or (\"Bad plan description!\" in str(result)):\n",
    "        invalid_plans += 1\n",
    "    else:\n",
    "        success += 1\n",
    "print(\"Validating --- {0}% --- Success rate {1}%\".format(\n",
    "    round(((i / min(n_samples, len(problems))) * 100), 1),\n",
    "    round((success / i * 100), 1)))\n",
    "\n",
    "print('Teriyaki failed %i plans' % invalid_plans)\n",
    "planning_steps = np.array(planning_steps)\n",
    "print(str(np.average(planning_steps)/len(planning_steps)))\n",
    "\n",
    "print(\"Validation complete!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final result comparison -  Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_f8d03\" style=\"font-size: 20px\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_f8d03_level0_col0\" class=\"col_heading level0 col0\" >Solver/Domain</th>\n",
       "      <th id=\"T_f8d03_level0_col1\" class=\"col_heading level0 col1\" >avg_steps</th>\n",
       "      <th id=\"T_f8d03_level0_col2\" class=\"col_heading level0 col2\" >min</th>\n",
       "      <th id=\"T_f8d03_level0_col3\" class=\"col_heading level0 col3\" >max</th>\n",
       "      <th id=\"T_f8d03_level0_col4\" class=\"col_heading level0 col4\" >avg</th>\n",
       "      <th id=\"T_f8d03_level0_col5\" class=\"col_heading level0 col5\" >std</th>\n",
       "      <th id=\"T_f8d03_level0_col6\" class=\"col_heading level0 col6\" >fails</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_f8d03_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_f8d03_row0_col0\" class=\"data row0 col0\" >Probe/Macro</td>\n",
       "      <td id=\"T_f8d03_row0_col1\" class=\"data row0 col1\" >11.111</td>\n",
       "      <td id=\"T_f8d03_row0_col2\" class=\"data row0 col2\" >0.009</td>\n",
       "      <td id=\"T_f8d03_row0_col3\" class=\"data row0 col3\" >36.711</td>\n",
       "      <td id=\"T_f8d03_row0_col4\" class=\"data row0 col4\" >2.112</td>\n",
       "      <td id=\"T_f8d03_row0_col5\" class=\"data row0 col5\" >3.470</td>\n",
       "      <td id=\"T_f8d03_row0_col6\" class=\"data row0 col6\" >12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_f8d03_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "      <td id=\"T_f8d03_row1_col0\" class=\"data row1 col0\" >Teiryaki/Macro</td>\n",
       "      <td id=\"T_f8d03_row1_col1\" class=\"data row1 col1\" >10.953</td>\n",
       "      <td id=\"T_f8d03_row1_col2\" class=\"data row1 col2\" >1.033</td>\n",
       "      <td id=\"T_f8d03_row1_col3\" class=\"data row1 col3\" >54.323</td>\n",
       "      <td id=\"T_f8d03_row1_col4\" class=\"data row1 col4\" >8.985</td>\n",
       "      <td id=\"T_f8d03_row1_col5\" class=\"data row1 col5\" >4.770</td>\n",
       "      <td id=\"T_f8d03_row1_col6\" class=\"data row1 col6\" >0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_f8d03_level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
       "      <td id=\"T_f8d03_row2_col0\" class=\"data row2 col0\" >Probe/No Macro</td>\n",
       "      <td id=\"T_f8d03_row2_col1\" class=\"data row2 col1\" >22.137</td>\n",
       "      <td id=\"T_f8d03_row2_col2\" class=\"data row2 col2\" >0.006</td>\n",
       "      <td id=\"T_f8d03_row2_col3\" class=\"data row2 col3\" >43.768</td>\n",
       "      <td id=\"T_f8d03_row2_col4\" class=\"data row2 col4\" >2.788</td>\n",
       "      <td id=\"T_f8d03_row2_col5\" class=\"data row2 col5\" >3.303</td>\n",
       "      <td id=\"T_f8d03_row2_col6\" class=\"data row2 col6\" >17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_f8d03_level0_row3\" class=\"row_heading level0 row3\" >3</th>\n",
       "      <td id=\"T_f8d03_row3_col0\" class=\"data row3 col0\" >Teiryaki/No Macro</td>\n",
       "      <td id=\"T_f8d03_row3_col1\" class=\"data row3 col1\" >19.158</td>\n",
       "      <td id=\"T_f8d03_row3_col2\" class=\"data row3 col2\" >0.440</td>\n",
       "      <td id=\"T_f8d03_row3_col3\" class=\"data row3 col3\" >54.705</td>\n",
       "      <td id=\"T_f8d03_row3_col4\" class=\"data row3 col4\" >14.614</td>\n",
       "      <td id=\"T_f8d03_row3_col5\" class=\"data row3 col5\" >7.163</td>\n",
       "      <td id=\"T_f8d03_row3_col6\" class=\"data row3 col6\" >0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f7da3e06610>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "results_1 = np.load('./timings/results.npy')\n",
    "results_2 = np.load('./timings/results_no_macro.npy')\n",
    "\n",
    "results = np.empty([4,6])\n",
    "\n",
    "results[:2,:] = results_1\n",
    "results[2:4,:] = results_2\n",
    "\n",
    "results_table = pd.DataFrame(results, columns=('avg_steps', 'min', 'max', 'avg', 'std', 'fails'))\n",
    "\n",
    "df = pd.DataFrame({'Solver/Domain': ('Probe/Macro', 'Teiryaki/Macro', 'Probe/No Macro', 'Teiryaki/No Macro')})\n",
    "df = pd.concat([df, results_table],axis=1)\n",
    "df = df.astype({\"fails\":\"int\"})\n",
    "\n",
    "df.style.\\\n",
    "    format(precision=3).\\\n",
    "    set_table_attributes('style=\"font-size: 20px\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final result comparison - Boxplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "timings_1 = np.load('./timings/timings.npy')\n",
    "timings_2 = np.load('./timings/timings_no_macro.npy')\n",
    "\n",
    "timings = np.empty([1000,4])\n",
    "\n",
    "timings[:,:2] = timings_1\n",
    "timings[:,2:4] = timings_2\n",
    "\n",
    "timings[:,[1, 2]] = timings[:,[2, 1]]\n",
    "\n",
    "dft = pd.DataFrame(timings, columns=['Probe/Macro', 'Probe/No Macro','Teiryaki/Macro', 'Teiryaki/No Macro'])\n",
    "\n",
    "props = dict(boxes=\"DarkBlue\", \n",
    "             whiskers=\"DarkBlue\", \n",
    "             medians=\"Yellow\", \n",
    "             caps=\"Gray\")\n",
    "\n",
    "boxplot = dft.plot.box(figsize=(16,10), \n",
    "                       fontsize=16, \n",
    "                       color=props, \n",
    "                       patch_artist=True,\n",
    "                       xlabel=\"Solver\",\n",
    "                       ylabel=\"seconds\",\n",
    "                       showfliers=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Action-by-action PDDL planning using streaming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PLANNING STARTS\n",
      "\n",
      "  2.55s - 0.00100: (release-links link3 link2 joint2 gleft gright)\n",
      "  3.30s - 0.00300: (link-to-central-grasp link2 link1 joint3 joint1 gleft gright)\n",
      "  4.13s - 0.00500: (decrease_angle_first_child link2 link1 joint1 angle300 angle285 gleft gright)\n",
      "  4.69s - 0.00700: (release-links link2 link1 joint1 gleft gright)\n",
      "  5.46s - 0.00900: (link-to-central-grasp link3 link2 joint1 joint2 gleft gright)\n",
      "  6.29s - 0.01100: (decrease_angle_first_child link3 link2 joint2 angle315 angle300 gleft gright)\n",
      "  7.13s - 0.01300: (decrease_angle_first_child link3 link2 joint2 angle300 angle285 gleft gright)\n",
      "  7.69s - 0.01500: (release-links link3 link2 joint2 gleft gright)\n",
      "  8.46s - 0.01700: (link-to-central-grasp link4 link3 joint2 joint3 gleft gright)\n",
      "  9.45s - 0.01900: (increase_angle_first_child_45 link4 link3 joint3 angle270 angle285 angle300 angle315 gleft gright)\n",
      " 10.42s - 0.02100: (increase_angle_first_child_45 link4 link3 joint3 angle315 angle330 angle345 angle0 gleft gright)\n",
      " 11.27s - 0.02300: (decrease_angle_first_child link4 link3 joint3 angle0 angle345 gleft gright)\n",
      "\n",
      "SOLVED\n",
      "\n",
      "Total planning time: 11.27s\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import time\n",
    "import subprocess\n",
    "import openai\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan_stream(query):\n",
    "    \n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt = query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1000,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # n = 4,\n",
    "                                        # best_of = 4,\n",
    "                                        stream = True,\n",
    "                                        stop = \"END\")\n",
    "\n",
    "    return response\n",
    "\n",
    "probf = open(\"./dataset/test/problems/problem_conditional_4_24_00001.pddl\", \"r\")\n",
    "\n",
    "prob_lines = probf.readlines()\n",
    "probf.close()\n",
    "\n",
    "prob_query = '\\n(:init\\n' + ''.join(prob_lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "\n",
    "# create variables to collect the stream of events\n",
    "collected_events = []\n",
    "completion_text = \"\"\n",
    "plan = \"\"\n",
    "cleaned = False\n",
    "\n",
    "start_time = time.time()\n",
    "response = GPT_Plan_stream(prob_query)\n",
    "\n",
    "# iterate through the stream of events\n",
    "print(\"\\nPLANNING STARTS\\n\")\n",
    "for event in response:\n",
    "    collected_events.append(event)  # save the event response\n",
    "    event_text = event['choices'][0]['text']  # extract the text\n",
    "    completion_text += event_text  # append the text\n",
    "    plan += event_text \n",
    "    action = completion_text.split(\"\\n\", 1)\n",
    "    \n",
    "    if len(action) > 1: # if there is at least one full action in the buffer...\n",
    "        if not cleaned:\n",
    "            action[0] = action[0][1:]\n",
    "            cleaned = True\n",
    "        event_time = time.time() - start_time  # calculate the time delay of the event\n",
    "        print(f\"{event_time:>6.2f}s - {action[0]}\")  # print the action\n",
    "        completion_text = action[1] # remove printed action from buffer\n",
    "    else:\n",
    "        continue\n",
    "\n",
    "if \" 0.00100\" in plan:  ## hotfix\n",
    "        plan = plan[1:]\n",
    "\n",
    "print(f\"\\nSOLVED\\n\\nTotal planning time: {event_time:.2f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compute Teriyaki single-action generation timings \n",
    "The time to generate a single action is computed on 1000 actions. We load the whole problems test set and keep planning until 1000 actions have been generated. This should roughly correspond to 100 problems. The last problem file name is printed for debug purposes.\n",
    "\n",
    "* For each problem, we start measuring time right before querying GPT-3.\n",
    "* We listen to the Openai stream and check whenever we receive the ```\\n``` character, which signals that a whole action has been generated\n",
    "* After the first action has been fully generated, we measure how much time passed\n",
    "* For each successive action we measure how much time passed since the previous\n",
    "\n",
    "**Note:** unlike before we are not going to replan again using Probe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 problems loaded\n",
      "Starting Teriyaki streaming test at 18:28:42\n",
      "Running Teriyaki streaming tests --- 100%0%\n",
      "Finished GPT test at 18:42:17\n",
      "Tests completed\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import time\n",
    "import subprocess\n",
    "import openai\n",
    "import numpy as np\n",
    "\n",
    "keyf = open(\"../key.txt\", \"r\")\n",
    "openai.api_key = keyf.read()\n",
    "keyf.close()\n",
    "\n",
    "def GPT_Plan_stream(query):\n",
    "    \n",
    "    response = openai.Completion.create(engine=\"davinci:ft-teriyaki:teriyaki-001-2022-12-01-00-28-34\",\n",
    "                                        prompt = query,\n",
    "                                        top_p = 1,       # modify ONLY top_p or temperature, not both       \n",
    "                                        temperature = 0, # argmax\n",
    "                                        max_tokens = 1900,\n",
    "                                        presence_penalty = 0, # -2 < x < 2, negative favors repetitions\n",
    "                                        frequency_penalty = 0,\n",
    "                                        # n = 4,\n",
    "                                        # best_of = 4,\n",
    "                                        stream = True,\n",
    "                                        stop = \"END\")\n",
    "\n",
    "    return response\n",
    "\n",
    "def Teriyaki_stream_planning(probf):\n",
    "    prob_lines = probf.readlines()\n",
    "    probf.close()\n",
    "\n",
    "    prob_query = '\\n(:init\\n' + ''.join(prob_lines[49:-1]).replace(\"    \", \"\") + '\\n\\n###\\n\\n'\n",
    "\n",
    "    # create variables to collect the stream of events\n",
    "    collected_events = []\n",
    "    completion_text = \"\"\n",
    "    planning_times = []\n",
    "    \n",
    "    last_action_time = time.time()\n",
    "    response = GPT_Plan_stream(prob_query)\n",
    "\n",
    "    # iterate through the stream of events\n",
    "    for event in response:\n",
    "        collected_events.append(event)  # save the event response\n",
    "        event_text = event['choices'][0]['text']  # extract the text\n",
    "        completion_text += event_text  # append the text\n",
    "        action = completion_text.split(\"\\n\", 1)\n",
    "\n",
    "        if len(action) > 1: # if there is at least one full action in the buffer...\n",
    "            now = time.time()\n",
    "            action_time = now - last_action_time  # calculate the time since last action\n",
    "            last_action_time = now\n",
    "            planning_times.append(action_time)\n",
    "            completion_text = action[1] # remove printed action from buffer\n",
    "        else:\n",
    "            continue\n",
    "\n",
    "    return planning_times\n",
    "\n",
    "problems = sorted(os.listdir('./dataset/test/problems/'))\n",
    "n_samples = 1000 ## limit number of actions\n",
    "print(\"{0} problems loaded\".format(min(n_samples, len(problems))))\n",
    "\n",
    "results = np.empty([2,6])\n",
    "timings = np.empty([min(n_samples, len(problems)),2])\n",
    "\n",
    "### Loading previous Probe timings\n",
    "\n",
    "probe_timings = np.load('./timings/timings.npy')\n",
    "probe_results = np.load('./timings/results.npy')\n",
    "timings[:,0] = probe_timings[:,0]\n",
    "results[0] = probe_results[0]\n",
    "\n",
    "### Test Teriyaki streaming\n",
    "\n",
    "comparison_results = []\n",
    "planning_times = []\n",
    "planning_steps = []\n",
    "fails = 0\n",
    "action = 0\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%H:%M:%S\", t)\n",
    "print(\"Starting Teriyaki streaming test at \" + current_time)\n",
    "\n",
    "print(\"Running Teriyaki streaming tests --- 0%\", end = '\\r')\n",
    "for problem in problems:\n",
    "    if len(planning_times) < n_samples:\n",
    "        probf = open('./dataset/test/problems/' + problem, \"r\")\n",
    "        problem_results = Teriyaki_stream_planning(probf)\n",
    "        planning_times.extend(problem_results)\n",
    "        planning_steps.append(len(problem_results))\n",
    "        probf.close()\n",
    "        print(\"Running Teriyaki streaming tests --- \" + str(round((len(planning_times) / n_samples * 100), 1)) +\"%\", end = '\\r')\n",
    "\n",
    "print(\"Running Teriyaki streaming tests --- 100%\")\n",
    "\n",
    "t = time.localtime()\n",
    "current_time = time.strftime(\"%H:%M:%S\", t)\n",
    "print(\"Finished GPT test at \" + current_time)\n",
    "\n",
    "planning_times = planning_times[:1000] # cleaning excess actions if any\n",
    "timings[:,1] = planning_times\n",
    "\n",
    "planning_times = np.array(planning_times)\n",
    "\n",
    "comparison_results.append(np.nanmean(planning_steps))\n",
    "comparison_results.append(np.nanmin(planning_times))\n",
    "comparison_results.append(np.nanmax(planning_times))\n",
    "comparison_results.append(np.nanmean(planning_times))\n",
    "comparison_results.append(np.nanstd(planning_times))\n",
    "\n",
    "comparison_results.append(fails)\n",
    "\n",
    "results[1] = comparison_results\n",
    "\n",
    "with open('./timings/results_streaming.npy', 'wb') as f:\n",
    "    np.save(f, results)\n",
    "    \n",
    "with open('./timings/timings_streaming.npy', 'wb') as f:\n",
    "    np.save(f, timings)\n",
    "    \n",
    "print(\"Tests completed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results table against Probe timings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_9d411\" style=\"font-size: 20px\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"blank level0\" >&nbsp;</th>\n",
       "      <th id=\"T_9d411_level0_col0\" class=\"col_heading level0 col0\" >SOLVER</th>\n",
       "      <th id=\"T_9d411_level0_col1\" class=\"col_heading level0 col1\" >avg_steps</th>\n",
       "      <th id=\"T_9d411_level0_col2\" class=\"col_heading level0 col2\" >min</th>\n",
       "      <th id=\"T_9d411_level0_col3\" class=\"col_heading level0 col3\" >max</th>\n",
       "      <th id=\"T_9d411_level0_col4\" class=\"col_heading level0 col4\" >avg</th>\n",
       "      <th id=\"T_9d411_level0_col5\" class=\"col_heading level0 col5\" >std</th>\n",
       "      <th id=\"T_9d411_level0_col6\" class=\"col_heading level0 col6\" >fails</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_9d411_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "      <td id=\"T_9d411_row0_col0\" class=\"data row0 col0\" >Probe</td>\n",
       "      <td id=\"T_9d411_row0_col1\" class=\"data row0 col1\" >11.111</td>\n",
       "      <td id=\"T_9d411_row0_col2\" class=\"data row0 col2\" >0.009</td>\n",
       "      <td id=\"T_9d411_row0_col3\" class=\"data row0 col3\" >36.711</td>\n",
       "      <td id=\"T_9d411_row0_col4\" class=\"data row0 col4\" >2.112</td>\n",
       "      <td id=\"T_9d411_row0_col5\" class=\"data row0 col5\" >3.470</td>\n",
       "      <td id=\"T_9d411_row0_col6\" class=\"data row0 col6\" >12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_9d411_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "      <td id=\"T_9d411_row1_col0\" class=\"data row1 col0\" >Teiryaki Streamer</td>\n",
       "      <td id=\"T_9d411_row1_col1\" class=\"data row1 col1\" >10.204</td>\n",
       "      <td id=\"T_9d411_row1_col2\" class=\"data row1 col2\" >0.512</td>\n",
       "      <td id=\"T_9d411_row1_col3\" class=\"data row1 col3\" >1.339</td>\n",
       "      <td id=\"T_9d411_row1_col4\" class=\"data row1 col4\" >0.815</td>\n",
       "      <td id=\"T_9d411_row1_col5\" class=\"data row1 col5\" >0.150</td>\n",
       "      <td id=\"T_9d411_row1_col6\" class=\"data row1 col6\" >0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f994c4bc280>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "results = np.load('./timings/results_streaming.npy')\n",
    "\n",
    "results_table = pd.DataFrame(results, columns=('avg_steps', 'min', 'max', 'avg', 'std', 'fails'))\n",
    "\n",
    "df = pd.DataFrame({'SOLVER': ('Probe', 'Teiryaki Streamer')})\n",
    "df = pd.concat([df, results_table],axis=1)\n",
    "df = df.astype({\"fails\":\"int\"})\n",
    "\n",
    "df.style.\\\n",
    "    format(precision=3).\\\n",
    "    set_table_attributes('style=\"font-size: 20px\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results boxplot against Probe timings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA60AAAIRCAYAAACh2ltlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAiY0lEQVR4nO3dfbhlZV038O9PRlSgQGACtXCQJM2yqPEBjTK0NDWNRyUvTIuelIp8CAMqUpuZrriypAdNowRf8KW6MpWKVDQVTCUzSDMzxDTwdXhVSEhEuJ8/1jp6POwzs+dln32fmc/nuva1Zq+3+3f2wFnz3fe97lWttQAAAECP7jbvAgAAAGA5QisAAADdEloBAADoltAKAABAt4RWAAAAuiW0AgAA0K018y5gGgceeGBbt27dvMsAAABgBi6//PLrW2trJ21bFaF13bp1ueyyy+ZdBgAAADNQVVcvt83wYAAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0a828CwBmZ9OmTfMuIUmyYcOGeZcAAMAqJbTCLmxHw2LVWWnttJ1UDQAAbDvDgwEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFsrHlqr6hlV1cbXs1a6fQAAAFaPFQ2tVfUdSV6W5Msr2S4AAACr04qF1qqqJK9OckOSP12pdgEAAFi9VrKn9eQkj0ry80luWcF2AQAAWKVWJLRW1YOTvDDJS1pr/7ASbQIAALD6zTy0VtWaJK9L8ukkvzXr9gAAANh1rFmBNn47yRFJjm6t/c+0B1XViUlOTJJDDjlkRqUBAADQs5n2tFbVkRl6V/+wtfaP23Jsa+3c1tr61tr6tWvXzqZAAAAAujaz0DoOC35tkiuTvGBW7QAAALDrmmVP6z5JDk/y4CRfqaq28EqyYdznvHHdi2dYBwAAAKvULO9pvS3JK5fZ9gMZ7nN9X5KPJ9mmocMAAADsHmYWWsdJl541aVtVbcwQWl/TWnvFrGoAAABgdVuR57QCAADA9hBaAQAA6NZcQmtrbWNrrQwNBgAAYEv0tAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3Zp5aK2q36+qd1XVZ6rqf6rqxqr6UFVtqKoDZt0+AAAAq9dK9LQ+N8neSf4+yUuS/FmSryXZmOQjVfUdK1ADAAAAq9CaFWjjW1trX1m6sqrOTPJbSc5IctIK1AEAAMAqM/Oe1kmBdfSGcfnAWdcAAADA6jTPiZieOC4/MscaAAAA6NhKDA9OklTVaUn2SbJvkvVJjs4QWF+4UjUAAACwuqxYaE1yWpKDFr2/KMkJrbXrJu1cVScmOTFJDjnkkNlXBwAAQHdWbHhwa+3g1lolOTjJk5M8IMmHquoHltn/3Nba+tba+rVr165UmQAAAHRkxe9pba1d01q7IMljkhyQ5LUrXQMAAACrw9wmYmqtXZ3kY0keUlUHzqsOAAAA+jXP2YOT5L7j8o65VgEAAECXZhpaq+rwqtp3wvq7VdWZSb4tyaWttS/Osg4AAABWp1nPHvz4JL9XVe9L8l9Jbsgwg/AjM0zEtDnJs2dcAwAAAKvUrEPrO5N8Z4Znsh6RZL8ktyS5MsnrkvxRa+3GGdcAAADAKjXT0Npa+2iS58yyDQAAAHZd856ICQAAAJYltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLemCq1VtXdV3W388+FV9aSquvtsSwMAAGB3N21P6z8kuWdV3S/JO5I8M8n5syoKAAAAkulDa7XWbk3y5CTntNaOS/KQ2ZUFAAAA2xBaq+rhSX4myVvGdXvMpiQAAAAYTBtaT0lyRpILWmv/XlUPSHLxzKoCAACAJGum2am19p4k71n0/lNJTp5VUQAAAJBsJbRW1YVJ2nLbW2tP2ukVAQAAwGhrPa1njcsnJzk4yevH98cnuWZWRQEAAECyldA6DgtOVf1ha239ok0XVtVlM60MAACA3d60EzHtPU6+lCSpqkOT7D2bkgAAAGAw1URMSZ6b5JKq+lSSSnL/JL84s6oAAAAg088efFFVPTDJg8ZVV7TWbptdWQAAADB9T2uS/GCSdeMx31dVaa29diZVAQAAQKYMrVX1uiSHJflwkjvG1S2J0AoAAMDMTNvTuj7Jd7fWln1mKwAAAOxs084e/NEMz2kFAACAFTNtT+uBST5WVR9M8vUJmFprT5pJVQAAAJDpQ+vGWRYBAAAAk0z7yJv3VNVBSR42rvpga+3a2ZUFAAAAU97TWlU/neSDSY5L8tNJ/qmqnjrLwgAAAGDa4cHPS/Kwhd7Vqlqb5J1J3rilg6rqgCT/O8kTknxvkvsl+WqSf0vy6iSvbq3duX2lAwAAsKubNrTebclw4BsyXS/tcUn+JMkXklyc5NNJDkry5CSvSPK4qjrOo3QAAACYZNrQelFVvT3JX4zvn5bkbVMcd2WSJyV5y+Ie1ar6rQzDjZ+SIcC+aeqKAQAA2G1MdU9ra+30JC9P8tDxdW5r7denOO7drbULlw4Bbq1tTvKn49sf3aaKAQAA2G1M1dNaVYcmeWtr7c3j+3tV1brW2lU70Pbt4/JrO3AOAAAAdmFT9bQm+aski3tL7xjXbZeqWpPkZ8e3F23veQAAANi1TRta17TWvrrwZvzznjvQ7guTfE+G3tu3T9qhqk6sqsuq6rLrrrtuB5oCAABgtZo2tF5XVU9aeFNVP5Xk+u1psKpOTnJqkiuSPHO5/Vpr57bW1rfW1q9du3Z7mgIAAGCVm3b24F9K8mdV9cdJWpLP5hvDe6dWVc9J8pIkH0vy6Nbajdt6DthdHHzwObnmmlvnXUaqzpp3CTnooL2yefNJ8y4DAIA5mCq0ttY+meSoqtpnfP/lbW2oqk5JcnaSj2YIrNdu+QjYvfUQWHvhswAA2H1NNTy4qg6qqlcm+avW2per6rur6hembaSqfiNDYP1wkmMEVgAAAKYx7T2t5yd5e5L7ju+vTHLKNAdW1QsyTLx0eYYe1u26FxYAAIDdz7T3tB7YWntDVZ2RJK21r1XVHVs7qKp+LsnvZHhEznuTnFxVS3e7qrV2/vQlAwAAsLuYNrTeUlUHZJiEKVV1VJKbpjju0HG5R5bvmX1Php5cAAAA+CbThtZfS/K3SQ6rqvcnWZvkqVs7qLW2McnG7S0OAACA3du097QeluRxSR6R4d7WT2T6wAsAAADbZdrQ+oLW2s1J7p3kmCTnJPmTmVUFAAAAmT60Lky69IQk57XW3pJkz9mUBAAAAINpQ+vnqurlSZ6W5K1VdY9tOBYAAAC2y7TB86cz3Mv62Nbal5Lsn+T0WRUFAAAAyZSTKbXWbk3y5kXvv5DkC7MqCgAAABJDfAEAAOiY0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtr5l0AAADsDJs2bZp3CUmSDRs2zLsE2KUIrQAA7BJ2RlisOiutnbYTqgF2FsODAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0a+ahtaqeWlUvrar3VtXNVdWq6vWzbhcAAIDVb80KtPH8JN+X5MtJPpvkQSvQJgAAALuAlRge/Nwkhyf51iS/vALtAQAAsIuYeU9ra+3ihT9X1aybAwAAYBdiIiYAAAC6JbQCAADQrW5Da1WdWFWXVdVl11133bzLAQAAYA66Da2ttXNba+tba+vXrl0773IAAACYg25DKwAAAAitAAAAdGvmj7wBAICtOfjgc3LNNbfOu4wkSdVZc23/oIP2yubNJ821BuiJnlYAAOaul8DaA58FfLOZ97RW1bFJjh3fHjwuH15V549/vr61dtqs6wAAAGD1WYnhwd+f5OeWrHvA+EqSq5MIrQAAANzFzIcHt9Y2ttZqC691s64BAACA1ck9rQAAAHRLaAUAAKBbQisAAADdEloBAADoltAKAABAt4RWAAAAuiW0AgAA0C2hFQAAgG4JrQAAAHRLaAUAAKBba+ZdAAAAtHb6vEvozGnzLgC6IbQCADB3VS+adwldaW3eFUA/DA8GAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAgLk76KC95l1CN3wW8M08pxUAgLnbvPmkeZeQJKk6K62dNu8ygEX0tAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALq1Zt4FAJO1dvq8S+iMB70DAOyOhFboVNWL5l1CV1qbdwUAAMyD4cEAAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaoVMHHbTXvEvohs8CAGD3tWbeBQCTbd580rxLSNVZae20eZcBAMBuTGgFAGCXsGnTph0+x8aNO36eDRs27HAdwDcIrQAA7BKERdg1uacVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQLaEVAACAbgmtAAAAdEtoBQAAoFtCKwAAAN0SWgEAAOiW0AoAAEC3hFYAAAC6JbQCAADQrRUJrVX17VX1qqr6fFXdVlVXVdWLq+reK9E+AAAAq9OaWTdQVYcluTTJtyX5myRXJPlfSX41yU9U1Q+11m6YdR0AAACsPivR03pOhsB6cmvt2Nbab7bWHpXk7CTfleTMFagBAACAVWimoXXsZX1MkquS/PGSzRuS3JLkmVW19yzrAAAAYHWadU/rMePyHa21OxdvaK39d5L3J9kryVEzrgMAAIBVaNb3tH7XuLxyme2fyNATe3iSd824FtjtbNq0aYeO37hxx8+RJBs2bNjhcwAAsHuadWjdd1zetMz2hfX7Ld1QVScmOTFJDjnkkJ1eGOwOhEUAAFa7bp/T2lo7t7W2vrW2fu3atfMuBwAAgDmYdWhd6Endd5ntC+u/NOM6AAAAWIVmHVo/Pi4PX2b7A8flcve8AgAAsBubdWi9eFw+pqq+qa2q+pYkP5Tk1iQfmHEdAAAArEIzDa2ttU8meUeSdUl+ZcnmTUn2TvK61tots6wDAACA1WnWswcnyUlJLk3yR1X16CT/keTIDM9wvTLJ81agBgAAAFahmc8ePPa2rk9yfoawemqSw5K8JMlRrbUbZl0DAAAAq9NK9LSmtfaZJD+/Em0BAACw6+j2Oa0AAAAgtAIAANAtoRUAAIBuCa0AAAB0S2gFAACgW0IrAAAA3RJaAQAA6JbQCgAAQLeEVgAAALoltAIAANAtoRUAAIBuCa0AAAB0q1pr865hq6rquiRXz7sO2A0dmOT6eRcBACvItQ/m4/6ttbWTNqyK0ArMR1Vd1lpbP+86AGCluPZBfwwPBgAAoFtCKwAAAN0SWoEtOXfeBQDACnPtg864pxUAAIBu6WkFAACgW0IrsE2q6oSqalV1wrxrAWDlzOv3f1WdP7a7bsr9W1VdMtuqgJUktMIqNF6QF7/uqKrrq+rdVfX0edcHwGxM+P2/tdcJ8665d1W1R1U9u6reU1U3VtXtVXVtVX2kql5RVU9asr8vb2GFrZl3AcAO2TQu757kQUl+KskxVbW+tfZr8ysLgBnZNGHdKUn2TfKSJF9asu3DO7HtC5J8IMkXduI5Z+HBSW6dZseq2iPJ3yX5iQyf3VuSfDbJnkkekuTpGa6vfzuLQoHpCK2wirXWNi5+X1WPTvL3SU6pqj9qrV01j7oAmI2lv/eToecvQ2h98Sx/77fWbkpy06zOv7O01q7Yht2PzxBY/zXJI8ef8euqaq8kR+7E8oDtYHgw7EJaa+9KckWSSvKwJKmqjeMwph+tqqdX1T9V1Zer6qqF46rqPlX1x1V1VVV9taquq6o3V9UPbqm9qnpCVV1aVbdU1Rer6o1V9cBl9t2rqs6oqg+P+3+5qv6xqo7feZ8AAItV1ZHj7+bN4+/3z1TVy6vqvhP2vWS8XuxZVb9dVR+vqtuq6vxx+zcNix2H1X6mqm6uqn2Waf+l4zFPXbTu2Kp6fVVdOV4Pbqmqy6vq5Kqa+t+mVfV9VfW5sf0fX7R+W+5pfcS4PH9pYE2S1tqtrbWLF537kiSvHt++eslQ7HXjPtNcd6e+Jo5/H8+pqrdW1dXj38mNVfXOqnrcMp/NVeNrn6o6e/x7+p+xvWPHfdZU1fOq6hNV9ZWq+mRVPWe5D6qqHjvWcP1Ywyer6kVVtd8W2v/Wqvp/459vr6qNy50ftkRPK+x6alwufZ7VqUl+PMmFSS7O8K18qurQJO9Lct8k707yF0m+I8lxSZ5QVU9prf3dhHaenORxGYaLXZLk+5M8JcPw5Ee01j7+9YKGC9q7kxyR5F+SvCrDl2aPTfLnVfWQ1trzd+SHBuCbVdX/yfDM0dsyDG/9TJIHJnlWkidW1VGttU9POPRNGb74fFuSv05y7aTzt9buqKrzMgxZPj7JeUvav1eSZyTZnORvFm16YZI7k/xTks9luB49KsPw5ocleeYUP9ujk7w5yS1JfqS19uGtHbOMG8bl4VPuf36GYcQ/leFnWtzul5bsu9x1d79s2zVx/wyfzaUZRlNdl+Q+SZ6Y5K1V9ezW2ism1Hr3cf/9x1r3zPD39KaqekySkzL0Ir8tw38jxyV5aVVd11r7y8UnqqoNSTYmuTHDcOprkzw0yWlJHl9VD2+t3byk/T3Hn3P/JO9IcnOS/5pQJ2xda83Ly2uVvTIE0jZh/Y9l+IfAnUnuP67bOO5/S5IjJhzz9nH785asf0SSr2W4oO+zaP0JC+0n+cklx/zquP5dS9afP67/9SXr75nkorHe75/35+rl5eW1Gl9Jrhp/x65btO7wJF9N8p9J7rdk/0cnuSPJBUvWXzKe5yNJDpzQzsLv/xMWrbtPktuTXLaF/c9csv6wCfveLclrxv2PXLJt4Rqybnz/jPFn+9jCtW7J/i3JJVN+dkeM57ozyesyfCF7l3Nu7XNYsn1r191tuiYmuUeSb59wnn2TfDRDkLzXMv9NXJjkHovW//C4/sYk/5xkv0XbHjB+Fh9acq5jxmMuXbz/ks/i7GXaf2eSvef9/4jX6n8ZHgyr2DgEaWNVnVlVb8xwsasM9zVdvWT3c1trH1py/LcneUySTyf5g8XbWmuXZuh13T/DRXypd7e79sC+LMknkzyqqu4/tnFAhn9gXNZaW9rGV5L8xlizWY8Bdp5fztDT9quttc8t3tCGW0n+NkNv67dMOPYFrbXrp2mktfaFDL2xP1h3vaXkFzMEsPOWHPPJCee5M0NvYjL0OE5UVb+Z5LUZeml/aMK1bpuM18VnJLlmXL4pyVVVdUNVXVBVT9yB00+67m7zNbG1dltr7bMTar8pQy/tvTPeEjTBKa212xYd894MvZ33TvIbrbUvLdr2qSTvT/I9NUxQteDkcfnsxfuPx5yfobf5Z5Zp/9TW2i3LbIOpGR4Mq9uGcdkyDEt6b5JXttZeP2HfD05Yd8S4fG9r7fYJ29+d4eJ6RIZ/JCz2nqU7t2Go2PuSHDYec3WGC+keSdoy97LcfVw+eMI2ALbPw8flI6tqUqD5tgy/mw9PcvmSbZOuF1tyTpKnZgipJyZJVX1vkqOSvK0tmRxqDG6nJ3l8ht69vZec737LtHN2kmMzBMtnjCFvh7XW3lBVF2ToUTw6w/Xr6LGtY6vqtRl6VZfedrM1kz7H7bomVtVDMnxmP5Khd/ueS46b9Jl9adIXBEk+n+TQ3PXvPRmGa69JcvD452T4b+n2JMdV1XETjtkzydqqOqC1dsOi9V/J0GsPO0xohVWstVZb3+vrNk9Yt++4XO7xBQvr95uw7ZqttLNw7gPG5cOy/DfBSTJxEg8AtsvC797Tt7LfpN+9k64Xy2qtXVxV/5Hk+Ko6tbX23xnDa5KXL953vJ/znzOEpg9m+EL0xgy3o+yX4TaTeyzT1I+My7/bWYF10c9we4b7Lt8x1rlHhnkaXpXkZzPM3/DX23jaSZ/jNl8Tq+qoDF8ir0my0Et+c8ZhxBnur530mS030/PXkq/31E7clm+E54Wa1+QbX5RvqebFofXa7Qj6MJHQCruPSReOhQvWwcscc58l+y120DLHLJzrpiXLs5tnxwKslIXfvfu2u06Qs0XbGTT+NMPw3p+pqtdkGKXzuQyT9iz2rAyBdVO762PbHp4htC7n2Awh8pVVdffW2nlb2HeHtNbuSPKGscf4+RkmivrrbT3NhHXbc018fpJ7JTmmtXbJ4g1VdUaG0DpLNyW5W2tt/208TmBlp3FPK+zeFu61ObqqJn2Jdcy4/JcJ2x65dMX4zfTRS879wQzfBv/wDtQJwLb5wLhcqd+9r0lya4Ye1qdl6DV95Rj+FvvOcfmmCee4y3Vlic9k6G39eJKXV9WvbHe10/vvcbl4ZNPCz7RHtt32XBO/M8mNSwPraGuf2c7wgST3Hocow1wIrbAbGyd2+Psk65KcsnhbVR2ZYSKIL2YYFrXUo6rqJ5ese06G+1kvXpgco7V2bZI/S7K+ql6wZHKHhbYOGx+9A8DO8bIM9yGeXVV3eZzL+OzPnRZox6Gmf57hftDfzRDsJvWEXjUuf3RJPUckOWOKdr6QIaj9W5KXVdWp21300O7xVfXjNeH5sFV1cJJnj2//YdGmhSGwh2xre9t5Tbwqyf5V9dAl+/1CtjBp1U509rg8ryY/33fvcQgzzIzhwcAvZZgt8EXjc9suyzee03pnkp8f709a6sIkF4yTV/xnhvtqHpfh3qSTluz7nAzPBvydJM8cJ2u6JsOzYR+c4b6e4+P5bQA7RWvtivE5ra9K8u9VdVGSKzPcq3hIhp6+65I8aCc2e06G4b/3S3LhpBlvM9zDenqSF1fVMUk+keH68JMZnrv6tK010lq7bjz27UnOqqp7ttbO3M6aj8wwJHnzeG1auA4dmuQJGYbl/k2SNy465h8z9CqfMk4qtXDv6kuXuU90qW29Jr44Qzh9X1W9IcNw3fUZRja9McMkWDPTWnvXOGvz7yX5RFW9daxtnyT3z/AlwvuS/MQs62D3JrTCbq619qmqWp/hnpnHZ/j2++YMj885s7X2z8sc+uYMD61/XoYL++3jujNaa1cuaePmqnpkhmFjT88wucU9M1ykP5HkuRl6fAHYSVprr6+qf01yaobbPR6T4dmhn88Qdv5yJ7f3oar6cIYvMV++zD6fH3t4X5ghdD02yRUZvux8Z6YIreN5bqyqRyd5W5LfHYPrC7aj7D/McB36sSQPHeu5Z4be1Esy9B7/+eL7fFtrX6yqp2SYmOiEfGP249dn+cmPFte+TdfE1tpF46N3np/h87kjwzDjYzLMvjzT0DrW8PtV9f4Mj785OsN9tDdluG/53AyfE8xMmdQLAIAdNT7z9fMZRtwcOj57FWCHuacVAICd4ZczDBk9R2AFdiY9rQAAbJeq2jdDWL1fhkmLbkzyXcvMhQCwXYRWAAC2S1WtyzApz21JLk/yf1trkx6TBrDdhFYAAAC65Z5WAAAAuiW0AgAA0C2hFQAAgG4JrQAAAHRLaAUAAKBbQisAAADd+v+0mToXOGDv7QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "dft = pd.DataFrame(timings, columns=['Probe','Teriyaki Streamer'])\n",
    "\n",
    "timings = np.load('./timings/timings_streaming.npy')\n",
    "\n",
    "props = dict(boxes=\"DarkBlue\", \n",
    "             whiskers=\"DarkBlue\", \n",
    "             medians=\"Yellow\", \n",
    "             caps=\"Gray\")\n",
    "\n",
    "boxplot = dft.plot.box(figsize=(16,9), \n",
    "                       fontsize=20, \n",
    "                       color=props, \n",
    "                       patch_artist=True,\n",
    "                       xlabel=\"Solver\",\n",
    "                       ylabel=\"seconds\",\n",
    "                       showfliers=False)  "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}