Tarefa 1 - Bandits.ipynb

{
 "metadata": {
  "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-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "![Imgur](https://i.imgur.com/ELdqWFi.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "<h2 align=\"center\">💸 Falindo o Cassino de Monte Carlo 💸</h2>\n",
    "\n",
    "Imagine que, após uma bem sucedida corrida no *Circuito de Mônaco*, você decidiu dar uma pausa na adrenalina do asfalto e passar em outra renomada atração turística da cidade, o famoso **Cassino de Monte Carlo**.\n",
    "\n",
    "Por conta de sua excentricidade e luxúria, os caça-níqueis (às vezes chamados de *one-armed bandits* em inglês) desse cassino funcionavam de uma maneira diferente que a de costume: cada máquina possuía 10 alavancas, com cada alavanca tendo uma certa chance de devolver uma certa quantidade de dinheiro. Como essas máquinas eram muito diferentes daquelas com que você estava acostumado, você decidiu observar um pouco alguns apostadores antes de participar do jogo. Com isso você observou que na média algumas alavancas devolviam mais dinheiro do que outras.\n",
    "\n",
    "Com sua astúcia, você logo percebeu que poderia aplicar um algoritmo de aprendizado por reforço para conseguir maximizar a quantidade de dinheiro recebida, possivelmente até falindo o cassino.\n",
    "\n",
    "![Imagem de um k-armed bandit](https://i.imgur.com/TxC4YwW.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Escrevendo a máquina caça-níquel em código\n",
    "\n",
    "A seguir vamos definir o que seria o ambiente (*enviroment* em inglês) do nosso algoritmo. Nesse caso, ele é a máquina caça-níquel (vamos começar a chamar de *bandit* daqui para frente), na qual você quer aprender qual é a melhor alavanca a se puxar para receber a maior quantidade de dinheiro."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bandit():\n",
    "\n",
    "    def __init__(self, k_arms=10):\n",
    "        # gera k números aleatórios uniformemente distribuídos entre -3 e 3\n",
    "        self.bandits_expectations = np.random.uniform(-3, 3, k_arms)\n",
    "    \n",
    "    def gamble(self, action):\n",
    "        \"\"\"ação(int) -> recompensa(int)\n",
    "        Recebe uma ação representando a alavanca que será acionada, \n",
    "        que devolve uma recompensa baseada em uma distribuição normal \n",
    "        de média definida no init e desvio padrão 1.\n",
    "        \"\"\"\n",
    "        return np.random.normal(self.bandits_expectations[action], 1)"
   ]
  },
  {
   "source": [
    "Deixamos o código em orientação a objetos porque é o mais comum para ambientes em Python.\n",
    " - `__init__` é o construtor do objeto. Nesse caso ele inicializa o objeto gerando *k* números aleatórios uniformemente distribuídos entre -3 e 3. Cada um desses valores será o valor esperado de retorno de cada alavanca.\n",
    " - `gamble` realiza uma das ações possíveis no ambiente e retorna a recompensa obtida. Para cada uma das *k* alavancas o agente pode escolher qual delas irá puxar. Por exemplo, se a ação escolhida for o `0` ele puxará a alavanca de índice `0`, que possui valor esperado definido aleatoriamente pelo `__init__`.\n",
    "\n",
    "Vamos brincar um pouco com nosso ambiente para entender ele melhor:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(31415)\n",
    "env = Bandit(5) # inicializa um bandit de 5 alavancas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vamos ver os valores esperados de cada uma das alavancas\n",
    "for i in range(len(env.bandits_expectations)):\n",
    "  print(f\"Alavanca {i} tem valor esperado {env.bandits_expectations[i]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.gamble(2) # puxar a alavanca de índice 2"
   ]
  },
  {
   "source": [
    "## Visualizando as distribuições do Bandit\n",
    "Por conta de como estão distribuídos os valores esperados, com certeza teremos alguma alavanca que possuí o maior valor esperado. Podemos visualizar isso construindo um gráfico que mostra como os valores estão distribuídos para cada alavanca:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "samples = [[env.gamble(0) for i in range(1000)],\n",
    "           [env.gamble(1) for i in range(1000)],\n",
    "           [env.gamble(2) for i in range(1000)],\n",
    "           [env.gamble(3) for i in range(1000)],\n",
    "           [env.gamble(4) for i in range(1000)]]\n",
    "\n",
    "plt.figure(figsize=(11,7))\n",
    "\n",
    "max_e = np.max(env.bandits_expectations)\n",
    "\n",
    "plt.title(\"Distribuição de cada alavanca de um bandit\")\n",
    "plt.violinplot(samples, [0,1,2,3,4])\n",
    "plt.axline((0,max_e), slope=0, ls=\"--\",c=\"red\", label=f\"Maior valor esperado = {max_e:.2f}\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.xlabel(\"Ação\")\n",
    "plt.ylabel(\"Recompensa\")\n",
    "plt.show()        "
   ]
  },
  {
   "source": [
    "Assim, com o gráfico podemos ver que realmente, a melhor alavanca a se puxar com o intuito de ganhar a maior quantidade de dinheiro é a de número 2. Porém, como podemos fazer com que o agente aprenda que essa é a melhor alavanca a se puxar também? Veremos isso na próxima seção."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "# 🥣 Criando um Algoritmo Guloso (*Greedy*)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Estimando  o valor esperado *Q*\n",
    "\n",
    "No nosso problema de $k$-Armed Bandits dizemos que para cada $k$ ações há uma recompensa média esperada; esse valor esperado geralmente é chamado de valor da ação. Ou seja, definimos o valor de uma ação arbitrária $a$, denotado de $q^{*}(a)$, como uma recompensa em um tempo $t$ ($R_t$) dado que a ação em $t$ ($A_t$) foi a como:\n",
    "\n",
    "$$q^*(a) = \\mathbb{E}[R_t | A_t=a]$$"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "> (Esse $\\mathbb{E}$ significa o valor esperado, é como se fosse a “recompensa média” — a recompensa com maior probabilidade de acontecer dado $a$.)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "Se nosso agente soubesse todos os valores esperados, o problema seria facilmente resolvido: ele simplesmente escolheria a ação com o maior valor. O problema é justamente que ele não sabe esses valores. Para obter alguma estimativa para esses valores, denotaremos as estimativas com a letra $Q$ maiúscula, já que normalmente em Aprendizado por Reforço nós usamos letras maiúsculas para representar algo aleatório ou um valor estimado.\n",
    "\n",
    "Como estamos buscando um valor esperado — ou seja, a recompensa média — basta calcularmos a média das recompensas recebidas por nosso agente naquela ação:\n",
    "$$Q_{n+1} = \\frac{1}{n}\\sum_{i=1}^{n}R_i$$\n",
    "\n",
    "Porém, como na computação seria custoso executar uma somatória toda vez que gostaríamos de atualizar Q podemos fazer algumas manipulações algébricas e cair na seguinte equação:\n",
    "$$Q_{n+1} = Q_n + \\frac{1}{n}(R_n - Q_n) $$\n",
    "\n",
    "Que é a equação que iremos usar em nosso algoritmo! Lembre-se que $n$, nesse caso, vai ser o número de vezes que aquela ação ocorreu. **Então teremos um $n$ e um $Q$ para cada ação**."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## A função argmax\n",
    "\n",
    "Agora que já sabemos como estimar os valores $Q$ temos que criar alguma função capaz de escolher a ação com o maior valor estimado. Essa é a função argmax!\n",
    "\n",
    "Ela é definida da seguinte maneira:\n",
    " - Recebe uma lista de valores\n",
    " - Verifica qual é o maior valor dessa lista\n",
    " - Retorna o **índice** desse valor\n",
    " - Em caso de empates, ela retorna o índice de um dos maiores valores aleatoriamente\n",
    "\n",
    "![diagrama da argmax](https://i.imgur.com/B3HJC6P.png)\n",
    "\n",
    "Seu primeiro exercício será implementar essa função!"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Exercício 1, implementando a função argmax\n",
    "Complete o código abaixo para implementar a função argmax especificada a cima."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def argmax(Q_values):\n",
    "    \"\"\" (lista) -> índice de maior valor(int)\n",
    "    Recebe uma lista dos valores Q e retorna o índice do maior valor.\n",
    "    Por definição, resolve empates escolhendo um deles aleatoriamente.\n",
    "    \"\"\"\n",
    "    max_value = float(\"-inf\")\n",
    "    ties = []\n",
    "\n",
    "    for i in range(len(Q_values)):\n",
    "        if ...:\n",
    "            pass\n",
    "        if ...:\n",
    "            pass\n",
    "\n",
    "    return ..."
   ]
  },
  {
   "source": [
    "## Definindo o agente\n",
    "Agora que já sabemos como podemos estimar os valores de $Q$ e como podemos escolher as ações de maior valor com a função argmax, podemos definir nosso **agente guloso**. Ele deverá ser composto da seguinte forma:\n",
    " - o construtor recebe o número de `k_arms` existentes no ambiente e inicializa os seguintes atributos:\n",
    "    - `n_arms`: vetor que guardará quantas vezes o agente realizou cada ação. Inicializado com um vetor de zeros com tamanho igual ao número de ações (alavancas).\n",
    "    - `Q_values`: vetor que armazena o $Q$ valor de cada ação. Inicializado com um vetor de zeros com tamanho igual ao número de ações (alavancas).\n",
    "    -  `last_action`: última ação do agente. Inicializada com uma ação aleatória.\n",
    "    \n",
    "- A função de `step` deve receber a recompensa do episódio e estar definida da seguinte maneira:\n",
    "   - Atualiza o vetor `n_arms` adicionando mais um ao $n$ da última ação realizada.\n",
    "   - Calcula o $Q$ atual conforme a fórmula definida.\n",
    "   - Atualiza o vetor `Q_values` atualizando o novo valor `Q` da última ação.\n",
    "   - Escolhe a próxima ação passando a lista atualizada de `Q_values` à função argmax.\n",
    "   - Atualizar a última ação do agente com a ação escolhida.\n",
    "   - Retorna a ação escolhida."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Exercício 2, implementando o agente guloso\n",
    "Complete o código abaixo conforme as definições:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GreedyAgent():\n",
    "    def __init__(self, k_arms):\n",
    "        self.n_arms = np.zeros(k_arms)\n",
    "        self.Q_values = np.zeros(k_arms)\n",
    "        self.last_action = np.random.randint(0, k_arms)\n",
    "\n",
    "    def agent_step(self, reward):\n",
    "        \"\"\" (float) -> acao(int)\n",
    "        Dá um step para o Agente atualizando os valores Q.\n",
    "        Pega a recompensas do estado e retorna a ação escolhida.\n",
    "        \"\"\" \n",
    "\n",
    "        self.n_arms[...] = ...\n",
    "        current_Q = ...\n",
    "        self.Q_values[...] = ...\n",
    "\n",
    "        current_action = ...\n",
    "        self.last_action = ...\n",
    "\n",
    "        return ..."
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Treinando o Agente\n",
    "Com o agente e o ambiente definidos, podemos finalmente treiná-lo!\n",
    "\n",
    "O código de treinamento deve ser definido como:\n",
    " - Inicializamos nosso agente `agent`, com `k_arms = 10`\n",
    " - Inicializamos nosso ambiente `env`, com `k_arms = 10`\n",
    " - Para cada `step` no número total de steps  `num_steps`\n",
    "    - Receber a recompensa do ambiente puxando a alavanca (`env.gamble`) representada pela última ação do agente (`agent.last_action`).\n",
    "    - Atualizar a estimativa de valor do agente (`agent.agent_step`)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Exercício 3, implementando o treinamento do agente\n",
    "Complete o código a baixo conforme as definições:\n",
    " "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 1_000\n",
    "\n",
    "agent = ...\n",
    "env = ...\n",
    "\n",
    "score = [0]\n",
    "means = []\n",
    "max_score = np.max(env.bandits_expectations)\n",
    "\n",
    "for step in range(n_steps):\n",
    "    reward = ... # Tome ação no ambiente\n",
    "\n",
    "    ... # Atualize a estimativa de valor do agente\n",
    "\n",
    "    score.append(score[-1] + reward)\n",
    "    means.append(score[-1]/(step+1))\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.title(\"Recompensa de uma simulação de um agente guloso\")\n",
    "plt.axline((0, max_score), slope=0, ls=\"--\", c=\"red\", label=\"Melhor possível\")\n",
    "plt.plot(means, label=\"Guloso\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Recompensa\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.show()"
   ]
  },
  {
   "source": [
    "Se tudo deu certo você verá o gráfico de uma simulação, com a recompensa comparada com a melhor possível. Você verá que, provavelmente, os resultados não são os melhores, mas existe uma chance de que, por conta de sorte, ele consiga a melhor pontuação. Para eliminar esse fator de sorte podemos executar a simulação várias vezes e pegar a média:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 1_000\n",
    "n_simulations = 200\n",
    "total_means = []\n",
    "\n",
    "max_means = 0\n",
    "for simulation in range(n_simulations):\n",
    "\n",
    "    agent = ...\n",
    "    env = ...\n",
    "\n",
    "    score = [0]\n",
    "    means = []\n",
    "\n",
    "    max_means += np.max(env.bandits_expectations)\n",
    "\n",
    "    for step in range(n_steps):\n",
    "        reward = ... # Tome ação no ambiente\n",
    "\n",
    "        ... # Atualize a estimativa de valor do agente\n",
    "\n",
    "        score.append(score[-1] + reward)\n",
    "        means.append(score[-1]/(step+1))\n",
    "\n",
    "    total_means.append(means)\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.title(\"Recompensa média de um agente guloso\")\n",
    "plt.axline((0, max_means/n_simulations), slope=0, ls=\"--\", c=\"red\", label=\"Melhor possível\")\n",
    "plt.plot(np.mean(total_means, axis=0), label=\"Guloso\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Recompensa Média\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.show()"
   ]
  },
  {
   "source": [
    "Por mais que o Algoritmo Guloso consiga chegar rapidamente a uma recompensa média relativamente grande, ele ficará preso a ela para sempre. Por não praticar exploração ele acabará não conhecendo outras ações que podem ser melhores e, na média, ficará preso a uma solução não otimizada.\n",
    "\n",
    "A solução para isso é o o **Algoritmo ε-Guloso** que possui uma chance aleatória de fazer uma ação de **exploração**!"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "# 🧭 Criando um Algoritmo ε-Guloso\n",
    "A ideia de um algoritmo é adicionar um parâmetro $\\varepsilon$, que controla a probabilidade do agente realizar uma ação aleatória de exploração. A seguir, discutimos um pouco mais sobre esses dois conceitos.\n",
    "\n",
    "## Exploração e Explotação\n",
    "\n",
    "Como no agente guloso nós sempre pegamos a ação de maior valor estimado até aquele momento, é fácil dele cair em soluções subótimas. Para resolver isso, introduzimos a ideia de **exploração** no algoritmo.\n",
    "\n",
    "A exploração é uma maneira do agente identificar cenários ainda não vistos, conhecendo melhor o valor de cada ação. A explotação, por sua vez, é utilizar esse conhecimento para tomar a melhor decisão. Uma analogia com o mundo real seria o menu de um restaurante: imagine que você pediu um prato lá e acabou gostando deste prato, você poderia sempre pedi-lo quando fosse nesse restaurante e acabaria feliz, porém, se não se arriscar a pedir nenhum outro prato nunca saberá se pode haver um prato do qual você acabe gostando mais!\n",
    "\n",
    "## Definindo o Agente\n",
    "No geral, o agente $\\varepsilon$-guloso é bem parecido com o agente guloso, a maior diferença sendo a presença desse novo parâmetro $\\varepsilon$ e a chance $\\varepsilon$ dele executar uma ação aleatória ao invés da de maior valor estimado.\n",
    "\n",
    "Com isso o código ficaria definido como:\n",
    " - No construtor, além do parâmetro `k_arms`, agora ele deve receber o parâmetro `epsilon`.\n",
    "    - Além dos atributos já definidos no agente guloso, agora ele também deve inicializar um atributo `self.epsilon` que armazena o valor de `epsilon`\n",
    " - Na função de `step` todos os passos de atualização dos vetores continuam os mesmos, o que muda é agora colocar a chance de executar uma ação aleatória\n",
    "    - Ao invés de só escolher a próxima ação com base no argmax você deve gerar um número real aleatório entre 0 e 1.\n",
    "    - Se esse número for menor que o epsilon, a próxima ação deve ser aleatória (um número inteiro aleatório entre 0 e número de braços-1)\n",
    "    - Se não, a próxima ação é a com maior $Q$ valor (passando a lista de valores $Q$ na argmax)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Exercício 4, implementado o agente ε-Guloso"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EpsilonGreedy():\n",
    "    def __init__(self, k_arms, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self.n_arms = np.zeros(k_arms)\n",
    "        self.Q_values = np.zeros(k_arms)\n",
    "        self.last_action = np.random.randint(0, k_arms)\n",
    "\n",
    "    def agent_step(self, reward):\n",
    "        \"\"\" (float) -> acao(int)\n",
    "        Dá um step para o Agente atualizando os valores Q.\n",
    "        Pega a recompensas do estado e retorna a ação escolhida.\n",
    "        \"\"\" \n",
    "\n",
    "        self.n_arms[...] = ...\n",
    "        current_Q = ...\n",
    "        self.Q_values[...] = ...\n",
    "\n",
    "        u = ... # número aleatório real entre 0 e 1\n",
    "\n",
    "        if ...:\n",
    "            current_action = ...\n",
    "        else:\n",
    "            current_action = ...\n",
    "\n",
    "        self.last_action = ...\n",
    "\n",
    "        return ..."
   ]
  },
  {
   "source": [
    "## Treinando o Agente\n",
    "O processo de treinamento é o mesmo, o único diferencial é que agora podemos testar diferentes resultados para diferentes valores de $\\varepsilon$.\n",
    " - Lembre-se de inicializar o agente e o ambiente. Para o agente, lembre de passar o parâmetro de `epsilon=eps`.\n",
    " - Dentro da lista `epsilons` escreva alguns valores para o parâmetro. Recomendamos três em específico: 0.1, 0.5 e 0 (se `epsilon = 0` então é só o algoritmo guloso), mas sinta-se livre para experimentar mais parâmetros.\n",
    " - Como foram os resultados obtidos? Qual é a relação de mudar o valor de $\\varepsilon$ e a média das recompensas médias?\n",
    " - Sinta-se livre para também testar valores de $\\varepsilon$ bem pequenos (0.01 por exemplo) e também aumentar o número de steps."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 3_000\n",
    "n_simulations = 20\n",
    "total_means = []\n",
    "max_means = []\n",
    "\n",
    "# coloque outros parâmetros para epsilon!\n",
    "epsilons = [0, 0.5, 0.1, ..., ...]\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "\n",
    "# Fazer 20 simulações, com 3.000 steps para cada epsilon eps\n",
    "for eps in epsilons: \n",
    "    max_mean = 0\n",
    "    for runs in range(n_simulations):\n",
    "\n",
    "        agent = ... # inicialize o agente com um epsilon diferente\n",
    "\n",
    "        env = ... \n",
    "\n",
    "        score = [0]\n",
    "        means = []\n",
    "\n",
    "        max_mean += np.max(env.bandits_expectations)\n",
    "\n",
    "        for step in range(n_steps):\n",
    "            reward = ... # Tome ação no ambiente\n",
    "\n",
    "            ... # Atualize a estimativa de valor do agente\n",
    "\n",
    "            score.append(score[-1] + reward)\n",
    "            means.append(score[-1]/(step+1))\n",
    "        total_means.append(means)\n",
    "\n",
    "    max_means.append(max_mean/n_simulations)\n",
    "    \n",
    "    plt.plot(np.mean(total_means, axis=0), label=f\"{eps}\")\n",
    "\n",
    "y = np.mean(max_means, 0)\n",
    "plt.axline((0, y), slope=0, ls=\"--\", c=\"red\", label=\"Melhor possível\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.title(\"Recompensa Média de um Agente Epsilon-Guloso\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Recompensa Média\")\n",
    "plt.show()"
   ]
  },
  {
   "source": [
    "Parabéns piloto! Se tudo deu certo você conseguirá ver os resultados do seu modelo, que mostram como essa simples mudança consegue, após um certo número de iterações, melhores resultados que um mero agente guloso!\n",
    "\n",
    "Agora, com seu modelo criado, você está pronto para faturar milhões no cassino de Monte Carlo, para depois gastar todo esse dinheiro em ***🍦 sorvetinhos 🍦 ***, obviamente.\n",
    "\n",
    "> Caso esteja interessado, você pode olhar também mais duas implementações que obtém resultados ainda melhores!\n",
    " - Bandits com [função softmax](https://github.com/turing-usp/Aprendizado-por-Reforco/tree/main/Aprendizado%20por%20Refor%C3%A7o%20Cl%C3%A1ssico/Bandits/SoftMax) que calculam um valor de *preferência* de uma ação.\n",
    " - Bandits com [limite de confiança superior](https://github.com/turing-usp/Aprendizado-por-Reforco/tree/main/Aprendizado%20por%20Refor%C3%A7o%20Cl%C3%A1ssico/Bandits/Limite%20de%20Confian%C3%A7a%20Superior) que utiliza um parâmetro de confiança para explorar e explotar.\n",
    " - Para um formalismo maior, você também pode ler o capítulo de Bandits no fantástico livro do [Sutton & Barton](https://web.archive.org/web/20210608124316/https://incompleteideas.net/book/RLbook2020.pdf) referência principal em Aprendizado por Reforço."
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}