Neuro_Evolução_Pousando_Foguetes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Neuro Evolução Pousando Foguetes.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JJDnWc90EVa",
        "cellView": "form"
      },
      "source": [
        "#@title\n",
        "%%capture\n",
        "!pip install gym pyvirtualdisplay\n",
        "!apt-get install -y xvfb python-opengl ffmpeg\n",
        "!apt-get install build-essential python-dev swig python-pygame\n",
        "!apt-get update\n",
        "!apt-get install cmake\n",
        "!pip install --upgrade setuptools\n",
        "!pip install ez_setup\n",
        "!pip install gym[atari]\n",
        "!pip install box2d-py"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LHBvJpgTpJDs",
        "cellView": "form"
      },
      "source": [
        "#@title\n",
        "%%capture\n",
        "\n",
        "import gym\n",
        "from gym.wrappers import Monitor\n",
        "import glob\n",
        "import io\n",
        "import base64\n",
        "from IPython.display import HTML, clear_output\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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xVgwYmVvJbJ7"
      },
      "source": [
        "import numpy as np\n",
        "import gym\n",
        "from matplotlib import pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrS82yMqWTiI"
      },
      "source": [
        "class Net():\n",
        "  def __init__(self, chromosome):\n",
        "    # 8 => 10 => 4\n",
        "    self.w1 = chromosome[:80].reshape((10,8))\n",
        "    self.b1 = chromosome[80:90].reshape((10,))\n",
        "    self.w2 = chromosome[90:130].reshape((4,10))\n",
        "    self.b2 = chromosome[130:].reshape((4,))\n",
        "  def forward(self, x):\n",
        "    s1 = np.dot(self.w1, x) + self.b1\n",
        "    z1 = s1 * (s1 > 0.0)\n",
        "    s2 = np.dot(self.w2, z1) + self.b2\n",
        "    z2 = s2 * (s2 > 0.0)\n",
        "    return z2.argmax()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qypaYO1SYAyd"
      },
      "source": [
        "def create_individual():\n",
        "  ''' Esta função cria o genótipo de um indivíduo\n",
        "      completamente aleatório\n",
        "  '''\n",
        "  N = 8*10+10+10*4+4\n",
        "  chromosome = np.random.normal(0, 10, size=(N,))\n",
        "  return chromosome, None"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-iFgTmovYk-j"
      },
      "source": [
        "def create_population(size):\n",
        "  ''' Aqui geramos uma população inteira\n",
        "  '''\n",
        "  # Nossa população será uma lista\n",
        "  population = list()\n",
        "  # Nesse laço criamos cada indivíduo\n",
        "  # e adicionamos à população\n",
        "  for _ in range(size):\n",
        "    population.append(create_individual())\n",
        "  return population"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fGjEBG8-YxTG"
      },
      "source": [
        "def get_phenotype(chromosome):\n",
        "  ''' Esta função gera a imagem a partir do\n",
        "      gene.\n",
        "  '''\n",
        "  n = Net(chromosome)\n",
        "  return n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TWC-698lY8Ru"
      },
      "source": [
        "def fitness(n):\n",
        "  R = 0.0\n",
        "  trials = 6\n",
        "  env = gym.make('LunarLander-v2')\n",
        "  for _ in range(trials):\n",
        "    obs = env.reset()\n",
        "    while True:\n",
        "      action = n.forward(obs)\n",
        "      obs, reward, done, info = env.step(action)\n",
        "      R += reward\n",
        "      if done:\n",
        "        break\n",
        "  env.close()\n",
        "  return (10000.0 + R/trials) / 10000.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F8wc66wqaZO9"
      },
      "source": [
        "def crossover2point(chr1, chr2):\n",
        "  ''' Esta função combina os genes de\n",
        "      dois indivíduos, gerando um novo\n",
        "      cromossomo\n",
        "  '''\n",
        "  N = len(chr1)\n",
        "  idx1 = np.random.randint(0,N)\n",
        "  idx2 = np.random.randint(0,N)\n",
        "  if idx1 > idx2:\n",
        "    idx1, idx2 = idx2, idx1\n",
        "  new_chr1 = np.concatenate((chr1[0:idx1], chr2[idx1:idx2], chr1[idx2:]))\n",
        "  new_chr2 = np.concatenate((chr2[0:idx1], chr1[idx1:idx2], chr2[idx2:]))\n",
        "  return new_chr1, new_chr2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cIqsJUFjah3c"
      },
      "source": [
        "def mutation(chr, p):\n",
        "  ''' Esta função aplica a mutação em um dos\n",
        "      genes de nosso cromossomo\n",
        "  '''\n",
        "  N = len(chr)\n",
        "  total = int(np.random.normal(p*N, p*N))\n",
        "  if total < 0:\n",
        "    total = 0\n",
        "  elif total > N:\n",
        "    total = N\n",
        "  for _ in range(total):\n",
        "    idx = np.random.randint(0, N)\n",
        "    if np.random.rand() > 0.5:\n",
        "      chr[idx] += np.random.normal(0, 1)\n",
        "    else:\n",
        "      chr[idx] = np.random.normal(0, 10)\n",
        "  return chr"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JmUo9vIibezR"
      },
      "source": [
        "def compute_fitness(population):\n",
        "  ''' Esta função avalia cada indivíduo\n",
        "      e adiciona o seu score.\n",
        "  '''\n",
        "  scored = list()\n",
        "  for chromosome, score in population:\n",
        "    n = get_phenotype(chromosome)\n",
        "    score = fitness(n)\n",
        "    scored.append((chromosome, score))\n",
        "  scored.sort(key=lambda x:x[1], reverse=True)\n",
        "  return scored"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uAC179ZScFeH"
      },
      "source": [
        "def roulette(population):\n",
        "  fitnesses = np.array([np.exp(fitness) \\\n",
        "                       for _, fitness in population])\n",
        "  total = np.sum(fitnesses)\n",
        "  fitnesses /= total\n",
        "  choice = np.random.rand()\n",
        "  subtotal = 0\n",
        "  idx = 0\n",
        "  for f in fitnesses:\n",
        "    subtotal += f\n",
        "    if subtotal >= choice or idx == len(fitnesses)-1:\n",
        "      break\n",
        "    idx += 1\n",
        "  return idx"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "963DTgCLcd0r"
      },
      "source": [
        "def new_generation(population, size, mutation_rate):\n",
        "  new_population = list()\n",
        "  while len(new_population) < size:\n",
        "    idx1 = roulette(population)\n",
        "    idx2 = roulette(population)\n",
        "    if idx1 == idx2:\n",
        "      continue\n",
        "    chr1, _ = population[idx1]\n",
        "    chr2, _ = population[idx2]\n",
        "    new_chr1, new_chr2 = crossover2point(chr1, chr2)\n",
        "    new_chr1 = mutation(new_chr1, mutation_rate)\n",
        "    new_chr2 = mutation(new_chr2, mutation_rate)\n",
        "    new_population.append((new_chr1, None))\n",
        "    new_population.append((new_chr2, None))\n",
        "  return new_population[:size]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f6EfRBbGdEan"
      },
      "source": [
        "def genalg(pop_size, elite_size, \\\n",
        "           epochs, mutation_rate):\n",
        "  x = list()\n",
        "  y = list()\n",
        "\n",
        "  population = create_population(pop_size)\n",
        "\n",
        "  for generation in range(epochs+1):\n",
        "\n",
        "    population = compute_fitness(population)\n",
        "\n",
        "    chr, fit = population[0]\n",
        "    _, worst = population[-1]\n",
        "    n = get_phenotype(chr)\n",
        "    y.append(fit)\n",
        "    x.append(generation)\n",
        "\n",
        "    R = 0.0\n",
        "    env2 = wrap_env(gym.make('LunarLander-v2'))\n",
        "    obs = env2.reset()\n",
        "    while True:\n",
        "      action = n.forward(obs)\n",
        "      obs, reward, done, info = env2.step(action)\n",
        "      env2.render()\n",
        "      R += reward\n",
        "      if done:\n",
        "        break\n",
        "    env2.close()\n",
        "\n",
        "    clear_output()\n",
        "    print('Geração', generation, ', melhor:', fit, ', pior', worst)\n",
        "    show_video()\n",
        "      \n",
        "    plt.plot(x, y)\n",
        "    plt.show()\n",
        "\n",
        "    elite = population[:elite_size]\n",
        "    population = new_generation(population, pop_size - elite_size,\\\n",
        "                                mutation_rate) + elite\n",
        "  return n, x, y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6aASS0aKejpa"
      },
      "source": [
        "#n, x, y = genalg(50, 3, 1000, 0.03)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sl3K20iRlBTn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 438
        },
        "outputId": "e38d06f6-b0aa-4378-f821-d344115c1150"
      },
      "source": [
        "env = wrap_env(gym.make('LunarLander-v2'))\n",
        "\n",
        "R = 0.0\n",
        "obs = env.reset()\n",
        "while True:\n",
        "  action = np.random.randint(0,4)\n",
        "  obs, reward, done, info = env.step(action)\n",
        "  env.render()\n",
        "  R += reward\n",
        "  if done:\n",
        "    break\n",
        "\n",
        "print(R)\n",
        "\n",
        "env.close()\n",
        "show_video()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-77.16412163723079\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<video alt=\"test\" autoplay \n",
              "                loop controls style=\"height: 400px;\">\n",
              "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
              "             </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}