MLGymGALunar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2U1cvSyEc8QL"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/EmmanuelADAM/IntelligenceArtificiellePython/blob/master/MLGymGALunar.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R1JGLAgwc8QT"
   },
   "source": [
    "# Machine Learning\n",
    "## Appliqué à [Gym.OpenAI]((https://gym.openai.com)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jAxBcni7c8QU"
   },
   "source": [
    "Voir la page d'[introduction à Gym](https://github.com/EmmanuelADAM/IntelligenceArtificiellePython/blob/master/TPMLIntroGym.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OkeRn1dSc8QV"
   },
   "source": [
    "### Installation de gym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x7FmTurCc8QV"
   },
   "source": [
    "#### Outil AUTRE QUE COLAB (pyzo, jupyter lab, .....)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t3tktHV8c8QV",
    "outputId": "e0ec7614-5e5d-4842-e7d0-a2619333db79"
   },
   "outputs": [],
   "source": [
    "!pip install gym\n",
    "!pip install Box2D\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "Fh6bGseSc8QW"
   },
   "outputs": [],
   "source": [
    "#GYM\n",
    "import gym\n",
    "import Box2D as b2\n",
    "\n",
    "#Random\n",
    "from random import  randint\n",
    "#\n",
    "from math import exp\n",
    "#for sorting\n",
    "import functools\n",
    "#array\n",
    "import numpy as np\n",
    "\n",
    "#for charts\n",
    "import matplotlib.pyplot as plt\n",
    "#On MAc : \n",
    "#import matplotlib\n",
    "#matplotlib.use(\"MacOSX\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XmkvWHemc8QW"
   },
   "source": [
    "#### <font color=red>Sous colab</font>\n",
    "*Sous colab, l'affichage ne sera pas dynamique.. Il faudra passer soit par un rendu sous forme de plot (matplotlib), soit passer par une vidéo à enregistrer...*\n",
    "\n",
    "***Solution pour affichage statique***<br>\n",
    "*Il vous faut importer, seulement si vous utilisez colab, les packages suivants :*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "F9fLsDsQc8QX",
    "outputId": "2ffa58ee-b724-4807-bbe9-6116d2313293"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Password:\n",
      "sudo: a password is required\n",
      "^C\n"
     ]
    }
   ],
   "source": [
    "!sudo apt-get update\n",
    "!pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "!apt-get install -y xvfb python-opengl ffmpeg > /dev/null 2>&1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KPaC4E6coJBd",
    "outputId": "22318698-0cab-4867-b6a5-18fda5b38f47"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already up-to-date: setuptools in /usr/local/lib/python3.7/dist-packages (56.0.0)\n"
     ]
    }
   ],
   "source": [
    "!apt-get update > /dev/null 2>&1\n",
    "!apt-get install cmake > /dev/null 2>&1\n",
    "!pip install --upgrade setuptools 2>&1\n",
    "!pip install ez_setup > /dev/null 2>&1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z2gvn7eFrVAr"
   },
   "outputs": [],
   "source": [
    "#GYM\n",
    "import gym\n",
    "from gym.wrappers import Monitor\n",
    "import glob\n",
    "import io\n",
    "import base64\n",
    "from IPython.display import HTML\n",
    "from pyvirtualdisplay import Display\n",
    "from IPython import display as ipythondisplay\n",
    "\n",
    "display = Display(visible=0, size=(1400, 900))\n",
    "display.start()\n",
    "\n",
    "\"\"\"\n",
    "Utility functions to enable video recording of gym environment \n",
    "and displaying it.\n",
    "To enable video, just do \"env = wrap_env(env)\"\"\n",
    "\"\"\"\n",
    "\n",
    "def show_video():\n",
    "  mp4list = glob.glob('video/*.mp4')\n",
    "  if len(mp4list) > 0:\n",
    "    mp4 = mp4list[0]\n",
    "    video = io.open(mp4, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    ipythondisplay.display(HTML(data='''<video alt=\"test\" autoplay \n",
    "                loop controls style=\"height: 400px;\">\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "             </video>'''.format(encoded.decode('ascii'))))\n",
    "  else: \n",
    "    print(\"Could not find video\")\n",
    "    \n",
    "\n",
    "def wrap_env(env):\n",
    "  env = Monitor(env, './video', force=True)\n",
    "  return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "RdRAbqsLc8QX"
   },
   "outputs": [],
   "source": [
    "#GYM\n",
    "import gym\n",
    "import Box2D as b2\n",
    "\n",
    "#Random\n",
    "from random import  randint\n",
    "#\n",
    "from math import exp\n",
    "#for sorting\n",
    "import functools\n",
    "#array\n",
    "import numpy as np\n",
    "\n",
    "#for charts\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M0CKlm8yc8QX"
   },
   "source": [
    "---\n",
    "## L'environnement LunarLander\n",
    "On se base ici sur l'environnement `LunarLander-v2`.\n",
    "\n",
    "### Charger la version originale de LunarLander\n",
    "On utilisera une version modifiée de l'environnement. Mais pour charger la version de base, sous tout outil autre que colab, on utilise la commande suivante : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "vslFd4bsc8QY"
   },
   "outputs": [],
   "source": [
    "env = gym.make('LunarLander-v2') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fq51caAquYXx"
   },
   "source": [
    "Mais **<font color=red>sous colab</font>** on utilise la commande"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "SMluStWEudGS"
   },
   "outputs": [],
   "source": [
    "env = wrap_env(gym.make(\"LunarLander-v2\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f6uBQVeSc8QY"
   },
   "source": [
    "---\n",
    "### Les valeurs des caractéristiques\n",
    "Pour `LunarLander-v2`, vous trouverez l'explication des valeurs [ici](https://gym.openai.com/envs/LunarLander-v2/).\n",
    "\n",
    "Il s'agit de faire atterrir une sonde sur une planète.\n",
    "\n",
    "L'espace des actions est une valeur discrète dans l'intervalle [0,3] : \n",
    "  - 0 : Ne rien faire\n",
    "  - 1 : allumage du moteur gauche\n",
    "  - 2 : allumage du moteur central\n",
    "  - 3 : allumage du moteur droit\n",
    "\n",
    "Les observations sont au nombre de 8 : \n",
    "  - obs[0] : coordonnée horizontale\n",
    "  - obs[1] : coordonnée verticale\n",
    "  - obs[2] : vitesse horizontale\n",
    "  - obs[3] : vitesse verticale\n",
    "  - obs[4] : angle de la sonde\n",
    "  - obs[5] : vitesse angulaire (de rotation)\n",
    "  - obs[6] : 1 si le pied gauche de la sonde est au contact du sol, 0 sinon\n",
    "  - obs[7] : 1 si le pied droit de la sonde est au contact du sol, 0 sinon\n",
    "\n",
    "Le but est donc de faire atterrir la sonde dans une position donnée (0,0) avec une vitesse suffisamment faible pour éviter le crash.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "09ECNjqVc8QY",
    "outputId": "5056721b-7f8e-4cdb-dd3b-2bed2a6e0783"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EnvSpec(LunarLander-v2)\n",
      "nombre et type d'actions =  Discrete(4)\n",
      "nombre et type d'observations =  Box(-inf, inf, (8,), float32)\n",
      "valeurs de  observations les plus basses =  [-inf -inf -inf -inf -inf -inf -inf -inf]\n",
      "valeurs de observations les plus elevées =  [inf inf inf inf inf inf inf inf]\n"
     ]
    }
   ],
   "source": [
    "print(env.spec)\n",
    "print(\"nombre et type d'actions = \", env.action_space) \n",
    "print(\"nombre et type d'observations = \", env.observation_space) \n",
    "print(\"valeurs de  observations les plus basses = \", env.observation_space.low) \n",
    "print(\"valeurs de observations les plus elevées = \", env.observation_space.high) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4H9Oy9y0c8QZ"
   },
   "source": [
    "___\n",
    "### Comportement non déterministe !\n",
    "`env.reset()` initialise les variables d'environnement. L'exécution est obligatoire après avoir chargé l'environnement. Ici ce sont les coordonnées de départ, l'angle d'attaque et les vitesses ont des valeurs tirées aléatoirement dans des intervales pré-définis. De plus les accélérations demandées ax moteurs sont elles aussi soumises à des variations.\n",
    "\n",
    "C'est donc un environnement non déterministe par défaut, `env.reset()` retourne des valeurs légèrement différentes à chaque exécution : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OeQdQyPVc8Qa",
    "outputId": "90f3ab5b-7b4f-4973-988c-053a0c23b331"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.00364351,  1.4210072 , -0.36906666,  0.4482938 ,  0.00422874,\n",
       "        0.08359913,  0.        ,  0.        ], dtype=float32)"
      ]
     },
     "execution_count": 29,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ORi7Ad0Gc8Qa"
   },
   "source": [
    "**<font color=red>L'algorithme génétique se prète mal aux environnement non stables</font>**; aussi dans cet exercice, **il faudra utiliser le code https://github.com/EmmanuelADAM/IntelligenceArtificiellePython/blob/master/lunarsourcegym.py que vous chargerez dans le même répertoire que votre code.** \n",
    "\n",
    "Cette version est une reprise du code de [Gym.OpenAI]((https://gym.openai.com), mais qui fixe les valeurs initiales du LunarLander et qui ôte les perturbations aléatoires lors des accélérations moteurs.\n",
    "\n",
    "Une fois le code chargé, pour utiliser l'environnement, il faut utiliser le code suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "bj1H4n1qc8Qa"
   },
   "outputs": [],
   "source": [
    "from lunarlanderdeterministe import MonLunarLander\n",
    "\n",
    "env = MonLunarLander()\n",
    "# sous collab, on écrira : \n",
    "# env = wrap_env(MonLunarLander())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On utilisera tout de même une fonction `reset()` pour fixer les angles et vitesses initiales : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reset():\n",
    "    \"\"\"reinitialisation de l'environnement monlunarlander et mise en place de l'angle d'attaque\"\"\"\n",
    "    env.reset();\n",
    "    env.lander.angle=0\n",
    "    env.lander.angularVelocity = 0\n",
    "    env.lander.ApplyForceToCenter( (0,0,), True)\n",
    "    env.lander.linearVelocity = b2.b2Vec2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9h3mgRypc8Qb"
   },
   "source": [
    "---\n",
    "### Les actions\n",
    "- Dans `LunarLander-v2`, comme indiqué plus haut, 0 n'allume aucun, 1 allume bièvement le moteur gauche, 2 allume bièvement le moteur central 3 allume bièvement le moteur droit.\n",
    "\n",
    "- ***Exécuter une action :***\n",
    "  - *exécution* : `observation, reward,done,info = env.step(action)`\n",
    "    - `observation`: ici les 8 éléments d'observation\n",
    "    - `reward`: utilité de l'état (récompense 100 si bien posé, -100 si crash)\n",
    "    - `done` : booléen (True si but (position) atteinte)\n",
    "    - `info` : éventuelle information retournée par l'outil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "px6f9SKSc8Qb"
   },
   "source": [
    "**Exemples d'actions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "DfPNsQDBc8Qb"
   },
   "outputs": [],
   "source": [
    "def test_action(no: int, nb: int = 1):\n",
    "    \"\"\"effectue nb fois l'action no dans l'environnement chargé\"\"\"\n",
    "    done:bool = False\n",
    "    i:int = 0\n",
    "    while i<nb and not done:\n",
    "        i += 1\n",
    "        env.render()\n",
    "        obs, reward, done, _ = env.step(no)\n",
    "        print(reward, done)\n",
    "    return done\n",
    "\n",
    "def test():\n",
    "  done = test_action(2, 40)\n",
    "  if (not done): done = test_action(0, 40)\n",
    "  if (not done): done = test_action(1, 40)\n",
    "  if (not done): done = test_action(3, 40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BUwg5Vf_c8Qb",
    "outputId": "87245a75-a118-43f6-efa9-f7a1697d2edc"
   },
   "outputs": [],
   "source": [
    "# sous collab : \n",
    "# env = wrap_env(MonLunarLander())\n",
    "reset()\n",
    "test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D-SnpGn6vNtE"
   },
   "source": [
    "\n",
    "\n",
    "**Sous Colab**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 421
    },
    "id": "DGcpVWwhvM_h",
    "outputId": "e1d4f1a0-67da-4ea4-ad4c-13123c009ca7"
   },
   "outputs": [],
   "source": [
    "env.close()\n",
    "show_video()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vbsgAW8c8kXe"
   },
   "source": [
    "ATTENTION, sous colab, bien répéter la ligne\n",
    "`env = wrap_env(MonLunarLander())' avant le reset et la création de vidéos\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TL9qn8nVc8Qc"
   },
   "source": [
    "---\n",
    "\n",
    "# Test d'algorithme génétique\n",
    "## Créer un programme évolutionnaire pour atteindre l'objectif\n",
    "- Utiliser l'environnement `LunarLander-v2`, car il est plus rapide \n",
    "- Programmez (en python) un algo génétique avec initialement les éléments suivants : \n",
    "  - sequence : tableau de valeurs entières 0, 1, 2 ou 3.\n",
    "  - 1 point de croisement (au centre)\n",
    "    - *(pour commencer, on pourrait proposer 2 points de croisement (au 1/3, et 2/3)), ou plus*\n",
    "  - taille sequence : taille_seq = 100\n",
    "  - taille population initiale : taille_pop = 100\n",
    "  - taux de gènes mutants dans une séquence : taux_mut_seq = 0.1\n",
    "  - taux de séquences mutantes dans la population : taux_mut_pop = 0.2\n",
    "  - nombre max de cycles de reproductions : nb_cycles = 3000\n",
    "\n",
    "\n",
    "- Pour tester une séquence, il suffit de balayer le tableau et de lancer l'action correspondante..\n",
    "- Les 4 meilleures séquences (11,22,33,44) se reproduisent entre elles, donnant donc 12 fils : 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43.\n",
    "- Idéalement, un filtre doit permettre de supprimer les séquences identiques qui pourraient venir des croisements et des mutations.\n",
    "\n",
    "- Tester votre algo sur le nb de générations et afficher le rendu toutes les 100 générations et bien sûr le rendu de la meilleure séquence finale.\n",
    "  - (uniquement la position finale *colab*)\n",
    "  - (sous forme d'animation sous autre outil)\n",
    "\n",
    "\n",
    "- ***NB:*** \n",
    "  - Au plus simple il est possible d'utiliser une population (liste) de couples [sequence, utilite] où l'utilité serait la distance en x."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### AIDE\n",
    "  - Pour commencer, on pourra se limiter aux actions 0 & 2.. Les séquences ne contiennent donc que des chiffres 0 & 2 placés aléatoirement au départ.\n",
    "  - **Pour évaluer une séquence**, on peut se baser sur le reward calculés par l'environnement. Mais il est plutôt recommandé de créer sa propre fonction d'évaluation. \n",
    "    - La zone d'arrivée se situe entre les drapeaux. Ces drapeaux ont pour coordonnées x respectivement -14 et +14. On peut aussi laisser une certaine marge de manoeuvre en y, dù à la hauteur de la sonde. ainsi une arrivée en y = +-5 entre les drapeaux pourra être considérée comme satisfaisante. La vitesse verticale doit être faible (<1 m/s). Et les \"pattes\" devront avoir été déployées.\n",
    "  - **Pour le croisement**, il est possible de choisir aléatoirement 4 séquences dans la population plutôt que les 4 premières.. Ou pseudo-aléatoirement, avec une plus grande chance d'être sélectionnée pour les meilleures séquences..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B-_UKQ_cc8Qc"
   },
   "source": [
    "---\n",
    "### V2 : Arrivée avec angle \n",
    "- Maintenant la sonde arrive avec un angle donné (0.3 par exemple) et une vitesse angulaire de 0.05..\n",
    "Il faut bien sûr maintenant activer les moteurs gauches et droits. Donc les séquences contiennent les chiffres 0 à 3.\n",
    "  - une mutation devra être douce.. Ainsi, à partir des actions 0 & 2, il est possible de muter vers les actions 0 à 3.\n",
    "  - mais à partir d'une actions 1 (respectivement 3), il n'est possible que de muter vers les actions 0,1,2 (respectivement 2,3,0).\n",
    "- Vérifiez que votre algorithme trouve bien la solution... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PhYAPxQ7c8Qd"
   },
   "outputs": [],
   "source": [
    "def reset2(angle, vitesse_angulaire):\n",
    "    env.reset();\n",
    "    env.lander.angle = angle\n",
    "    env.lander.angularVelocity = 0\n",
    "    env.lander.ApplyForceToCenter( (\n",
    "            0,0,\n",
    "            ), False)\n",
    "    env.lander.linearVelocity = b2.b2Vec2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zcIOeCqD9M6T"
   },
   "outputs": [],
   "source": [
    "reset2(0.3, 0.05)\n",
    "#application de l'algo..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "### BONUS\n",
    "Cherchez les séquences les plus courtes pour les deux cas de figure.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "MLGymGALunar.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}