S25_sorter_decision_theory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "WOVLuwFCvNzI",
   "metadata": {},
   "source": [
    "# Decision Theory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Zf5s_buof0JW",
   "metadata": {
    "colab_type": "text",
    "tags": [
     "no-tex"
    ]
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/gtbook/robotics/blob/main/S25_sorter_decision_theory.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "eQpmpMFPgrah",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "1eb10a06-4b94-420b-edd9-1620b93cefdd",
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install -q -U gtbook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "q_GZYB52hE4U",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "from gtbook.discrete import Variables\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import gtsam\n",
    "import plotly.express as px\n",
    "try:\n",
    "    import google.colab\n",
    "except:\n",
    "    import plotly.io as pio\n",
    "    pio.renderers.default = \"png\"\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "JXvILVB6oC9h",
   "metadata": {},
   "source": [
    "```{index} planning; decision theory\n",
    "```\n",
    "\n",
    "> Decision theory is about turning information into action."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69cf41f5",
   "metadata": {
    "tags": [
     "no-pdf"
    ]
   },
   "source": [
    "<img src=\"Figures2/S25-Trash_sorting_robot_with_gripper-05.jpg\" alt=\"Splash image with robot thinking about what to do\" width=\"40%\" align=center style=\"vertical-align:middle;margin:10px 0px\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ZWW1M_vb15T",
   "metadata": {},
   "source": [
    "Planning is simple for the trash sorter robot.  At each time instant, the robot makes a decision about what\n",
    "action to take and then executes that action.\n",
    "There is no coupling between actions, \n",
    "and there is no dependence on the current action to establish conditions that will ensure success at future stages.\n",
    "Thus, planning reduces to simple decision making: at this moment, based on the best information\n",
    "available, what single action should the robot execute. \n",
    "This process is repeated each time a new item of trash arrives.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "SIANxEJPuNQI",
   "metadata": {},
   "source": [
    "## Naive Decision Making Using Priors\n",
    "\n",
    "> A robot without sensors can make naive decisions using prior information. \n",
    "\n",
    "Consider the case of a trash sorting robot that is not equipped with any sensing capabilities.\n",
    "How can this robot make a decision about how to act in the world? \n",
    "Without sensing, the best information that is available is the prior knowledge the robot has about the world.\n",
    "In our case, this knowledge is encoded as the prior probability $P(C)$ over the categories of trash. \n",
    "Looking back at the table of priors in the previous sections, we see that paper occurs about 30% of the time\n",
    "and that cardboard occurs about 20% of the time, meaning that the paper bin is the appropriate destination\n",
    "about 50% of the time.\n",
    "We could adopt a simple decision rule for selecting actions:\n",
    "*Choose the action that maximizes the prior probability of making the right choice.*\n",
    "This would result in the robot always putting trash in the paper bin.\n",
    "If we do this, we expect that the robot will do the right thing around 50% of the time. This isn't great, but it's better than any other action, given the typical distribution of categories of trash.\n",
    "This approach, however, takes no account of the cost of wrong actions, which can result in significant problems."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "DIVHEX5uxe6S",
   "metadata": {},
   "source": [
    "## Optimizing for the Worst Case\n",
    "\n",
    "> A conservative approach to accounting for costs is to minimize the damage that can occur in the worst case scenario.\n",
    "\n",
    "One way to account for the costs of actions would be to apply an action that minimizes the worst-case cost.\n",
    "This provides a quantitative upper bound on how badly things could go.\n",
    "Denote by $\\mathrm{cost}(a_i,c)$ the cost of applying action $a_i$ when the piece of trash\n",
    "in the work cell is from category $c$.\n",
    "We then write our decision rule as a minimization problem\n",
    "\\begin{equation}\n",
    "a^* = \\arg \\min_{a_i} \\max_{c \\in \\Omega} \\mathrm{cost}(a_i,c).\n",
    "\\end{equation}\n",
    "\n",
    "From the table of costs given in previous sections, we see that this approach leads\n",
    "to always executing the *nop* action, since the worst-case cost for this action is 1,\n",
    "while the worst-case costs for the other three actions are 6, 2, and 10.\n",
    "This approach, however, merely reduces our trash sorting\n",
    "system to a conveyor belt that allows all items of trash to pass through, unsorted.\n",
    "In this case, the conservative action is to take no action, and\n",
    "the robot becomes a motionless spectator."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "zrA_YIus7xbM",
   "metadata": {},
   "source": [
    "## Minimizing Expected Cost\n",
    "\n",
    "> If the system will operate over a long period of time, we can optimize the long-term average cost.\n",
    "\n",
    "When there is uncertainty about the world state, what is the right way to choose\n",
    "actions to minimize costs? \n",
    "The ideal decision would always minimize the cost of executing each action, but because our knowledge of the world is uncertain (captured in the prior probability distribution),\n",
    "it is impossible to know which action this would be. \n",
    "In such cases, the concept of $expectation$ from probability theory (introduced above) provides a principled way to reason about decisions.\n",
    "\n",
    "The idea of expected cost is this: what do we expect to be the average cost of performing an action many times.\n",
    "The expected value for the cost of applying action $a$\n",
    "is merely the weighted average of the costs $cost(a,c)$, where the weights are exactly the prior probabilities assigned to the categories, $c$:\n",
    "\\begin{equation}\n",
    "E[ cost(a, C) ] = \\sum_{c \\in \\Omega} cost(a,c) P(c) \n",
    "\\end{equation}\n",
    "\n",
    "In the equation above for expectation, the notation $E [ cost(a, C) ]$ denotes the expected cost for executing the action $a$ with the expectation being taken with respect to the randomly occurring trash category $C$.\n",
    "We use upper case $C$ to indicate that the category is a random quantity, and that the expectation\n",
    "should be computed with respect to the probability distribution on categories\n",
    "(i.e., the priors given in the previous section).\n",
    "\n",
    "We can now formulate our decision process as the following minimization problem\n",
    "\\begin{equation}\n",
    "a^* = \\arg \\min_{a_i} E[ cost(a_i, C) ]\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Bkv_MTwxpoxb",
   "metadata": {},
   "source": [
    "### Implementation in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "_K_2oELxakIX",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 175
    },
    "outputId": "5e94e251-8d60-4d64-82f4-737716526b50"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cardboard</th>\n",
       "      <th>paper</th>\n",
       "      <th>can</th>\n",
       "      <th>scrap metal</th>\n",
       "      <th>bottle</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>glass bin</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>metal bin</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>paper bin</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>nop</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           cardboard  paper  can  scrap metal  bottle\n",
       "glass bin          2      2    4            6       0\n",
       "metal bin          1      1    0            0       2\n",
       "paper bin          0      0    5           10       3\n",
       "nop                1      1    1            1       1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# as before, in S12:\n",
    "categories = [\"cardboard\", \"paper\", \"can\", \"scrap metal\", \"bottle\"]\n",
    "actions = [\"glass bin\", \"metal bin\", \"paper bin\", \"nop\"]\n",
    "cost = np.array([[2,  2,  4,  6,  0],\n",
    "                 [1,  1,  0,  0,  2],\n",
    "                 [0,  0,  5, 10,  3],\n",
    "                 [1,  1,  1,  1,  1]])\n",
    "pd.DataFrame(cost, index=actions, columns=categories)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "di31ZivjOeaD",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 175
    },
    "outputId": "b11a5aad-32ed-48d4-9296-e0b580cf5f32"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<p>  <i>P(0):</i></p>\n",
       "<div>\n",
       "<table class='DecisionTreeFactor'>\n",
       "  <thead>\n",
       "    <tr><th>0</th><th>value</th></tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr><th>0</th><td>0.2</td></tr>\n",
       "    <tr><th>1</th><td>0.3</td></tr>\n",
       "    <tr><th>2</th><td>0.25</td></tr>\n",
       "    <tr><th>3</th><td>0.2</td></tr>\n",
       "    <tr><th>4</th><td>0.05</td></tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/markdown": [
       " *P(0):*\n",
       "\n",
       "|0|value|\n",
       "|:-:|:-:|\n",
       "|0|0.2|\n",
       "|1|0.3|\n",
       "|2|0.25|\n",
       "|3|0.2|\n",
       "|4|0.05|\n"
      ],
      "text/plain": [
       "Discrete Prior\n",
       " P( 0 ) Choice(0) \n",
       " 0 Leaf  0.2\n",
       " 1 Leaf  0.3\n",
       " 2 Leaf 0.25\n",
       " 3 Leaf  0.2\n",
       " 4 Leaf 0.05\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variables = Variables()\n",
    "Category = variables.discrete(\"Category\", categories)\n",
    "category_prior = gtsam.DiscreteDistribution(Category, \"200/300/250/200/50\")\n",
    "category_prior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "BSI-wIa3SD-w",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "b37c80e2-7e4c-45db-b4f3-2242802cb2ab"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.2, 0.6, 3.4, 1. ])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cost @ category_prior.pmf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "O3OxPcQBmuRD",
   "metadata": {},
   "source": [
    "Using the table above, it is clear that the optimal action given only the prior distribution on\n",
    "categories is to always place the trash item in the metal bin.\n",
    "If we wish to improve upon this, it will be necessary for the robot to somehow improve\n",
    "its knowledge of the world state.  This can be done by using sensors to measure various\n",
    "properties of the world, and then drawing inferences about the world state using these measurements.\n",
    "We now turn our attention to this problem."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pHJKb_M9KgNo",
   "metadata": {},
   "source": [
    "## Incorporating Sensor Information\n",
    "\n",
    "> We can exploit sensor information to make better decisions.\n",
    "\n",
    "Above, we learned how to compute the posterior $P(C|S)$ using MAP estimation.\n",
    "We can use this conditional distribution to compute the expectation of the\n",
    "cost of an action given that the sensor returned a specific measurement.\n",
    "This can be done by modifying the usual equation for expectation so\n",
    "that the conditional distribution $P(C|S)$ is used instead of the prior $P(C)$: \n",
    "\\begin{equation}\n",
    "E[ cost(a, C) | S=s ] = \\sum_{c \\in \\Omega} cost(a,c) P(c|S=s) \n",
    "\\end{equation}\n",
    "Our decision process can then be formulated as a minimization of this conditional\n",
    "expected cost:\n",
    "\\begin{equation}\n",
    "a^*(S=s) = \\arg \\min_a E [ cost(a, C) | S=s ]\n",
    "\\end{equation}\n",
    "\n",
    "Note that this approach can also be applied when we have multiple sensors by conditioning\n",
    "on the collection of sensor readings, say $s_1, \\dots, s_n$:\n",
    "\\begin{equation}\n",
    "E[ cost(a, C) | S_1=s_1, \\dots, S_n=s_n ] = \\sum_{c \\in \\Omega} cost(a,c) P(c|S_1=s_1, \\dots, S_n=s_n ) \n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9GeM9jDbcVPO",
   "metadata": {},
   "source": [
    "In python, we just calculate the expected cost, now using the posterior instead of the prior, and take argmin using `np.argmin`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7Oy9GTBr0PBl",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "6497fa09-2248-4c61-fa5a-6ba97530869a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expected_cost=[2.  1.1 2.4 1. ], optimal action=3\n"
     ]
    }
   ],
   "source": [
    "posterior = np.array([0.2, 0.3, 0.1, 0.1, 0.3])\n",
    "expected_cost = cost @ posterior\n",
    "optimal_action = np.argmin(expected_cost)\n",
    "print(f\"expected_cost={expected_cost}, optimal action={optimal_action}\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "S25_sorter_decision_theory.ipynb",
   "provenance": []
  },
  "interpreter": {
   "hash": "95ec9ec1504d83f612128e0fb229072f90bbb4cb09d9d5d93b5dd26e0ca2cfd1"
  },
  "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.12"
  },
  "latex_metadata": {
   "affiliation": "Georgia Institute of Technology",
   "author": "Frank Dellaert and Seth Hutchinson",
   "title": "Introduction to Robotics"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}