GymTaxiDoubleQLearningTODO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/EmmanuelADAM/IntelligenceArtificiellePython/blob/master/GymTaxiDoubleQLearningTODO.ipynb\" target=\"_parent\">Ouvrir sous colab</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning\n",
    "## Appliqué à [Gym.OpenAI](https://gym.openai.com)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Test de ML par Q-Learning pour atteindre des objectifs\n",
    "\n",
    "**Utilisation de l'environnement gymnasium**\n",
    " (voir la page d'introduction à [gymnasium](https://www.gymlibrary.dev/))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Si besoin, importer gym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install gymnasium "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "----\n",
    "#### L'environnement Taxi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "- Utiliser l'environnement `Taxi-v3`\n",
    "  - le taxi peut se trouver sur une grille 5x5\n",
    "  - le passager peut se trouver : dans le taxi, ou dans un des 4 points B(3),G(1),R(0),Y(2). \n",
    "  - il y a en tout $500$ états possibles : $25\\times 5 \\times 4$\n",
    "  - chaque état est representé par un ensemble: (rangee_taxi, colonne_taxi, position_passager, destination_passager)\n",
    "\n",
    "- les actions sont :\n",
    "  - 0: sud, 1: nord, 2: est, 3: ouest, 4: prendre un passager, 5: déposer un passager\n",
    "\n",
    "- les récompenses sont : \n",
    "    - dépôt d'un passager à destination : +20 points\n",
    "    - action prise en charge incongrue d'un passager : -10 points\n",
    "    - dans les autres cas, chaque état coûte 1 point\n",
    "\n",
    "- Chaque action coûte 1 point, l'arrivée n'en rapporte pas.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### Etude de l'environnement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "specification de l'environnement :  EnvSpec(Taxi-v3)\n",
      "espace d'actions :  Discrete(6)\n",
      "espace d'etats :  Discrete(500)\n",
      "********l'etat initial change à chaque reset***** ici s=  373\n",
      "--> cela correspond à un taxi en (3,3), un passager partant de B pour G\n",
      "Prendre une action au hasard.. \n",
      "action choisie= ouest ; l'exécuter...\n",
      "nouvel état=373, recompense sur cet etat=-1, etat final (but)=False, info={'prob': 1.0}\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "| : : : : |\n",
      "| | : |\u001b[43m \u001b[0m: |\n",
      "|Y| : |\u001b[34;1mB\u001b[0m: |\n",
      "+---------+\n",
      "  (West)\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('Taxi-v3', render_mode='ansi') \n",
    "print(\"specification de l'environnement : \", env.spec)\n",
    "print(\"espace d'actions : \", env.action_space ) #ici 4 actions discrétisée\n",
    "print(\"espace d'etats : \", env.observation_space) #ici 48 cellules possibles\n",
    "actions = { 0:'sud', 1:'nord', 2:'est', 3:'ouest', 4:'prendre un passager', 5: 'déposer un passager'}\n",
    "lieux = {0:'R', 1:'G', 2:'Y', 3:'B'}\n",
    "\n",
    "s = env.reset()\n",
    "print(env.render())\n",
    "\n",
    "print(\"********l'etat initial change à chaque reset***** ici s= \",s)\n",
    "x,y,passager_start, passager_end  = env.decode(s[0])\n",
    "print(f\"--> cela correspond à un taxi en ({x},{y}), un passager partant de {lieux[passager_start]} pour {lieux[passager_end]}\")\n",
    "\n",
    "print(\"Prendre une action au hasard.. \")\n",
    "a = env.action_space.sample()\n",
    "print(\"action choisie=\",actions[a],\"; l'exécuter...\")\n",
    "#on recupère des valeurs en retour\n",
    "new_s, reward, done, truncated, info = env.step(a)\n",
    "print(f\"nouvel état={new_s}, recompense sur cet etat={reward}, etat final (but)={done}, etat feuille={truncated}, info={info}\")\n",
    "#note sous python 3.10, la version de gym retourne 5 valeurs : \n",
    "#new_s, reward, done, goal, info = env.step(a)\n",
    "#print(f\"nouvel état={new_s}, recompense sur cet etat={reward}, etat final (but)={done},etat but={goal}, info={info}\")\n",
    "\n",
    "print(env.render())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### Test des actions\n",
    "\n",
    "Sous Gym, `step` permet d'effectuer une action. \n",
    "En retour la fonction retourne une observation sur l'etat d'arrivee, sa recompense, son type (final ou non), et des informations.\n",
    "\n",
    "Avec la librairie gym installé sous python 3.9, step retourne : \n",
    "  - observation = position où se trouve l'agent,\n",
    "  - reward = recompense,\n",
    "  - done = vrai si état final atteint,\n",
    "  - info = probabilité de succès de l'action.\n",
    "  \n",
    "Avec la librairie gym installé sous python 3.10, step retourne : \n",
    "  - observation = position où se trouve l'agent,\n",
    "  - reward = recompense,\n",
    "  - done = vrai si état final atteint,\n",
    "  - goal = vrai si but atteint,\n",
    "  - info = probabilité de succès de l'action."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### <font color=\"red\">Résolution</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exemple d'algorithme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random as rnd\n",
    "\n",
    "env = gym.make('Taxi-v3', render_mode='ansi') \n",
    "actions = { 0:'sud', 1:'nord', 2:'est', 3:'ouest', 4:'prendre un passager', 5: 'déposer un passager'}\n",
    "lieux = {0:'R', 1:'G', 2:'Y', 3:'B'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialiser la Q-Table\n",
    "# autant de cases que l'environnement en possède, \n",
    "# contenant autant de valeurs que d'actions possibles\n",
    "# donc ici une matrice 500 x 4\n",
    "QA = np.zeros([env.observation_space.n,env.action_space.n])\n",
    "QB = np.zeros([env.observation_space.n,env.action_space.n])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mise en place des paramètres\n",
    "\n",
    "Pour rappel avec l'algo de Double Q Learning, on réalise, plus ou moins alternativement :\n",
    "  - $a^* \\gets  argmax_{a} QA(s', a)$,\n",
    "  - $Q_A(s,a) \\gets Q_A(s,a) + \\lambda \\times (r + \\gamma \\times Q_B(s', a^*))-  Q_A(s,a))$ <br>\n",
    "ou<br>\n",
    "  - $b^* \\gets  argmax_{a} Q_B(s', a)$\n",
    "  - $Q_B(s,a) \\gets Q_B(s,a) + \\lambda \\times (r + \\gamma \\times QA(s', b^*))-  Q_B(s,a))$<br>\n",
    "avec \n",
    "    - $\\lambda$ : coef d'apprentissage\n",
    "    - $\\gamma$ : coef de réduction \n",
    "    - $r$ : récompense\n",
    "\n",
    "Cette équation note la qualité de l'action *a* à partir de l'état *s* alternativement dans les tables $Q_A$ et $Q_B$.\n",
    "\n",
    "Initialement, les actions sont choisies aléatoirement et notées; puis au fil des tests les actions les plus valuées sont choisies. Pour cela, un tirage est effectuée, s'il est inférieur à un $\\epsilon$, le choix est aléatoire. Cet $\\epsilon$ décroit au fil des tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda_learn = .2\n",
    "gamma = 0.99\n",
    "epsilon = 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Récupérer la meilleure action\n",
    "`argmax(tab)` retourne l'indice de la plus grande valeur du tableau.\n",
    "\n",
    "`argmax(Q[2])` retourne donc le no de l'action la plus intéressante à partir de l'état 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L'algorithme de DoubleQ-Learning "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(QA[0, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "##algorithme de Q-Learning simple\n",
    "def q_learn(nb_actions=64):\n",
    "    \"\"\"\n",
    "    effectue un cycle d'apprentissage/recherche de solution' via le Q-Learning simple\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    epoch : no de l'etape\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    total_r : recompense totale\n",
    "    r : recompense du dernier etat rencontre\n",
    "    states_list : liste des etats traverses\n",
    "    actions_list : liste des actions effectuees\n",
    "    goal : but atteint\n",
    "\n",
    "    \"\"\"\n",
    "    s = env.reset()\n",
    "##A CONTINUER\n",
    "    return total_r, r, states_list, actions_list, done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def try_qlearn(nb_episodes = 4000, nb_actions = 64):\n",
    "    \"\"\"\n",
    "    lance nb_episodes fois un cycle de Q-Learning et memorise chaque solution trouvee\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    solutions_list : liste des solutions (no, recompense totale, liste des etats, liste des actions)\n",
    "    \"\"\"\n",
    "    global epsilon\n",
    "##A CONTINUER\n",
    "\n",
    "    if(len(solutions_list) == 0): print(\"aucune solution trouvee !!\")\n",
    "    return solutions_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Affichage de du résultat\n",
    "Affichons maintenant la liste des actions via l'environnement Gymnasium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exemple_solution():\n",
    "    \"\"\" affiche un exemple de solution calculée à partir d'une des tables Q\"\"\"\n",
    "    s = env.reset()\n",
    "    s = s[0]\n",
    "    x,y,depart_passager, arrivee_passager = env.decode(0)\n",
    "    print(f\"à partir de ({x},{y}), prendre un client en {lieux[depart_passager]} pour l'amener en {lieux[arrivee_passager]}\")\n",
    "    goal = False\n",
    "    while not goal:\n",
    "        a = np.argmax(QA[s, :])\n",
    "        s,_,goal,_,_ = env.step(a)\n",
    "        x,y,pos_passager, but_passager = env.decode(s)\n",
    "        goal = pos_passager==but_passager\n",
    "        print(env.render())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+\n",
      "|\u001b[34;1mR\u001b[0m: | : :G|\n",
      "| : | : : |\n",
      "| :\u001b[43m \u001b[0m: : : |\n",
      "| | : | : |\n",
      "|\u001b[35mY\u001b[0m| : |B: |\n",
      "+---------+\n",
      "  (North)\n"
     ]
    }
   ],
   "source": [
    "##ON LANCE LA RESOLUTION : \n",
    "solutions = try_qlearn(15000, 50)\n",
    "if(len(solutions)==0):print(\"pas de solution...\")\n",
    "#relancer le bloc si pas de solution trouvee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+\n",
      "|\u001b[34;1mR\u001b[0m: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "|\u001b[43m \u001b[0m: : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (West)\n",
      "+---------+\n",
      "|\u001b[34;1mR\u001b[0m: | : :\u001b[35mG\u001b[0m|\n",
      "|\u001b[43m \u001b[0m: | : : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (North)\n",
      "+---------+\n",
      "|\u001b[34;1m\u001b[43mR\u001b[0m\u001b[0m: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (North)\n",
      "+---------+\n",
      "|\u001b[42mR\u001b[0m: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (Pickup)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "|\u001b[42m_\u001b[0m: | : : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (South)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "|\u001b[42m_\u001b[0m: : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (South)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "| :\u001b[42m_\u001b[0m: : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (East)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : : |\n",
      "| : :\u001b[42m_\u001b[0m: : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (East)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : |\u001b[42m_\u001b[0m: : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (North)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : | :\u001b[42m_\u001b[0m: |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (East)\n",
      "+---------+\n",
      "|R: | : :\u001b[35mG\u001b[0m|\n",
      "| : | : :\u001b[42m_\u001b[0m|\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (East)\n",
      "+---------+\n",
      "|R: | : :\u001b[35m\u001b[42mG\u001b[0m\u001b[0m|\n",
      "| : | : : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (North)\n",
      "+---------+\n",
      "|R: | : :\u001b[35m\u001b[34;1m\u001b[43mG\u001b[0m\u001b[0m\u001b[0m|\n",
      "| : | : : |\n",
      "| : : : : |\n",
      "| | : | : |\n",
      "|Y| : |B: |\n",
      "+---------+\n",
      "  (Dropoff)\n"
     ]
    }
   ],
   "source": [
    "##ON TESTE UNE RESOLUTION : \n",
    "if(len(solutions)>0):exemple_resolution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "def plot_frequence_sol(solutions_list):\n",
    "    \"\"\"\n",
    "    dessine la frequence de solution trouvees\n",
    "    Parameters\n",
    "    ----------\n",
    "    solutions : liste des solutions\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    None.\n",
    "\n",
    "    \"\"\"\n",
    "    xs = [x[0] for x in solutions_list]\n",
    "    ys = [y[1] for y in solutions_list]\n",
    "    plt.figure(figsize=(10, 4))\n",
    "    plt.plot(xs, ys, '.')\n",
    "    plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_frequence_sol(solutions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np.round(QA, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plus on relance les tests, plus on a de chance de trouver une solution peu coûteuse apparaît..."
   ]
  }
 ],
 "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}