exercicios 1.1, 2.3, 3.1, 4.2, 5.1, 6.2, 8.2, 9.2

Capítulo 1/Ex_1.01.md

@@ -15,3 +15,11 @@ Resposta 2:
 ```
 Neste caso os algoritmos iriam valorizar os estados de maneiras diferentes. Imagine o jogo Tic Toc onde o jogador A sempre começa jogando. Dessa forma o Jogador B nunca viu o tabuleiro vazio e portando nao saberia qual posição escolher quando visse pela primeria vez o tabuleiro vazio. Os jogadores apesar de usarem o mesmo algoritmo de aprendizagem por reforço poderiam aprender politicas diferentes pois cada jogador teria suas próprias experiências.
 ```
+
+
+---
+Resposta 3:
+
+```
+Sem a interação do agente com jogadas de oponentes humanos, o agente iria aprender a modificar e alcançar o objetivo (Vitória) por meio de jogadas próprias. Sendo assim, o aprendizado estaria enviesado a políticas e escolhas de ações restritas ao comportamento do agente com o ambiente modificado pelo próprio agente. Portanto, as ações estando ligadas a ele mesmo iriam por muitas vezes parecer sem sentido. Desta forma, fica claro que  suas políticas de escolhas são diferentes de uma escolha humana.
+```

Capítulo 11/Ex_11.03.ipynb

@@ -0,0 +1,122 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### *Exercise 11.3*\n",
+    "\n",
+    "#### (programming) Apply one-step semi-gradient Q-learning to Baird’s counterexample and show empirically that its weights diverge. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "#### Resposta 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "class QAsg:\n",
+    "    def __init__(self, state_values, b, alpha=0.1, gamma=0.99):\n",
+    "        self.state_values = state_values\n",
+    "        self.W = np.random.random((9,1))\n",
+    "        self.alpha = alpha\n",
+    "        self.gamma = gamma\n",
+    "        self.b = b\n",
+    "        self.SA_dict = {}\n",
+    "        self.diverged_list = []\n",
+    "\n",
+    "    def SA(self, state, action):\n",
+    "        global SA\n",
+    "        if (state,action) in self.SA_dict:\n",
+    "            return self.SA_dict[(state,action)]\n",
+    "        else:\n",
+    "            feature = np.array(self.state_values[state] + [action])\n",
+    "            feature = np.reshape(feature, (-1,1))\n",
+    "            self.SA_dict[(state,action)] = feature\n",
+    "            return feature\n",
+    "\n",
+    "    def Q(self, state, action):\n",
+    "        return [email protected](state, action)\n",
+    "\n",
+    "\n",
+    "    def update(self,state, next_state, action):\n",
+    "        delta = self.gamma*max(self.Q(next_state, 0),self.Q(next_state,1)) - self.Q(state,action)\n",
+    "        self.W = self.W + self.alpha*delta*self.SA(state, action)\n",
+    "\n",
+    "    def diverge(self,n_eps):\n",
+    "        for episode in range(1,n_eps+1):\n",
+    "            self.W = np.random.random((9,1))\n",
+    "            _,state = self.b()\n",
+    "            for t in range(1,10000):\n",
+    "                action, next_state = self.b()\n",
+    "                self.update(state, next_state, action)\n",
+    "                state = next_state\n",
+    "                if self.W.max() >= 1e10:\n",
+    "                    self.diverged_list.append((episode, t))\n",
+    "                    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": "No Episodio 1 divergiu na iteração 1817\nNo Episodio 2 divergiu na iteração 2012\nNo Episodio 3 divergiu na iteração 1779\nNo Episodio 4 divergiu na iteração 1633\nNo Episodio 5 divergiu na iteração 1695\nNo Episodio 6 divergiu na iteração 1556\nNo Episodio 7 divergiu na iteração 1895\nNo Episodio 8 divergiu na iteração 1772\nNo Episodio 9 divergiu na iteração 1826\nNo Episodio 10 divergiu na iteração 1697\nNo Episodio 11 divergiu na iteração 1761\nNo Episodio 12 divergiu na iteração 1712\nNo Episodio 13 divergiu na iteração 1749\nNo Episodio 14 divergiu na iteração 1560\nNo Episodio 15 divergiu na iteração 1543\nNo Episodio 16 divergiu na iteração 1743\nNo Episodio 17 divergiu na iteração 1737\nNo Episodio 18 divergiu na iteração 1670\nNo Episodio 19 divergiu na iteração 1749\nNo Episodio 20 divergiu na iteração 1724\nNo Episodio 21 divergiu na iteração 1710\nNo Episodio 22 divergiu na iteração 1769\nNo Episodio 23 divergiu na iteração 1774\nNo Episodio 24 divergiu na iteração 1796\nNo Episodio 26 divergiu na iteração 1760\nNo Episodio 27 divergiu na iteração 1743\nNo Episodio 28 divergiu na iteração 1706\nNo Episodio 29 divergiu na iteração 1705\nNo Episodio 31 divergiu na iteração 1787\nNo Episodio 32 divergiu na iteração 1830\nNo Episodio 33 divergiu na iteração 1724\nNo Episodio 34 divergiu na iteração 1664\nNo Episodio 35 divergiu na iteração 1641\nNo Episodio 36 divergiu na iteração 1635\nNo Episodio 37 divergiu na iteração 1888\nNo Episodio 38 divergiu na iteração 2026\nNo Episodio 39 divergiu na iteração 1726\nNo Episodio 40 divergiu na iteração 1800\nNo Episodio 41 divergiu na iteração 1824\nNo Episodio 42 divergiu na iteração 1624\nNo Episodio 43 divergiu na iteração 1755\nNo Episodio 44 divergiu na iteração 1685\nNo Episodio 46 divergiu na iteração 1587\nNo Episodio 47 divergiu na iteração 1773\nNo Episodio 48 divergiu na iteração 1835\nNo Episodio 49 divergiu na iteração 1779\nNo Episodio 50 divergiu na iteração 1607\n"
+    }
+   ],
+   "source": [
+    "def b():\n",
+    "        dice = np.random.random()\n",
+    "        if dice > 1/7:\n",
+    "            return 0, np.random.randint(low=0, high=6)\n",
+    "        else:\n",
+    "            return 1, 6\n",
+    "dv_dw = [[2, 0, 0, 0, 0, 0, 0, 1],\n",
+    "        [0, 2, 0, 0, 0, 0, 0, 1],\n",
+    "        [0, 0, 2, 0, 0, 0, 0, 1],\n",
+    "        [0, 0, 0, 2, 0, 0, 0, 1],\n",
+    "        [0, 0, 0, 0, 2, 0, 0, 1],\n",
+    "        [0, 0, 0, 0, 0, 2, 0, 1],\n",
+    "        [0, 0, 0, 0, 0, 0, 1, 2]]\n",
+    "qadiv = QAsg(dv_dw, b)\n",
+    "qadiv.diverge(50)\n",
+    "for ep, it in qadiv.diverged_list:\n",
+    "    print(f'No Episodio {ep} divergiu na iteração {it}')"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.9.4-final"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

Capítulo 11/README.md

@@ -0,0 +1,8 @@
+# Chapter 11: n-step Bootstrapping - Exercises
+
+Exercises list:
+
+- [ ] 11.1
+- [ ] 11.2
+- [ ] 11.3
+- [ ] 11.4

Capítulo 2/Ex_2.03.md

@@ -24,3 +24,11 @@ Resposta 2:
 ```
 Quando o "e-greedy" é médio o algoritmo pode escolher uma maquina muito ruim e por azar a recompensa dela for muito alta, dessa forma iria demorar mais para o algoritmo perceber que aquela maquina é de fato ruim. Com "e-greedy" é muito pequeno acontece algo pior pois com o raciocinio de sempre escolher a melhor ação o algoritmo pode achar uma maquina que lhe dar 3 como recompensa enquanto que a maioria das outras lhe dão -1. Porem pode existir uma maquina que lhe der 10 como média. A grande questão é escolher o valor certo da explotação/exploração
 ```
+
+
+---
+Resposta 3:
+
+```
+Sim, o de e = 0.01 pois mesmo que lentamente este explora mais as ações disponíveis e desta forma encontrando melhores ações a longo prazo. Seu desempenho em determinado estado de tempo converge a um melhor que o de 0.1 e o de ação gananciosa (0).
+```

Capítulo 3/Ex_3.01.md

@@ -13,3 +13,20 @@ Em um jogo de Xadrez, a próxima ação depende apenas da disposição das peça
 
 * Exemplo 3:
 ```
+
+
+---
+Resposta 2:
+
+```
+* Exemplo 1:
+A tarefa de melhoramento de rota de limpeza de robô aspirador de pó inteligente que sabe determinar sua posição no ambiente por reforço. As recompensas da tarefa são de 1 para toda ação tomada, -1 para ações tomadas que levem a um estado visitado e 0 para o objetivo atingido. O ambiente é uma sala de 16m² que contém móveis que modificam as rotas do aspirador. As ações desta tarefa se baseiam em mover-se para frente, para trás, esquerda e direita com chances equiprováveis. Quando uma ação é escolhida ela tem 1 de ocorrer.
+
+* Exemplo 2:
+Tarefa de recomendação de filmes para usuários, onde o ambiente é um streaming de filmes e séries, as suas ações são tomadas com base nas características de filmes assistidos e avaliados pelo usuário, e a recompensa se dar com base no filme assistido e na avaliação dada pelo usuário, sendo penalizado por filmes que for mal avaliado ou não assistido.
+
+* Exemplo 3:
+[1] realizou em seu trabalho uma tentativa de reconfiguração autónoma de parâmetros em sistemas web multicamadas em ambientes que eram dinâmicos e baseados em VM 's. O processo foi formulado como um espaço de estados sendo a configuração do sistema, as ações eram {aumentar, diminuir, manter} para cada parâmetro e a recompensa definida como diferença entre o tempo de resposta determinando qual tempo iria ser mantido.
+
+[1] BU, Xiangping; RAO, Jia; XU, Cheng-Zhong. A reinforcement learning approach to online web systems auto-configuration. In: 2009 29th IEEE International Conference on Distributed Computing Systems. IEEE, 2009. p. 2-11.
+```

Capítulo 4/Ex_4.01.md

@@ -10,4 +10,4 @@ Ao executar o policy evaluation chegamos numa função estado-valor como mostrad
 
     qπ(11, down) = R11-T + vπ(T) = -1 + 0 = -1
     qπ(7, down) = R7-11 + vπ(11) = -1 + -14 = -15
-```
+```

Capítulo 4/Ex_4.02.md

@@ -0,0 +1,10 @@
+### *Exercise 4.2:*
+
+**In Example 4.1, suppose a new state 15 is added to the gridworld just below state 13, and its actions, left, up, right, and down, take the agent to states 12, 13, 14, and 15, respectively. Assume that the transitions from the original states are unchanged. What, then, is vπ(15) for the equiprobable random policy? Now suppose the dynamics of state 13 are also changed, such that action down from state 13 takes the agent to the new state 15. What is vπ(15) for the equiprobable random policy in this case?**
+
+---
+Resposta 1:
+
+```
+Para esta politica equiprovavel o vπ(15) é um estado inexplorado e inalcançavel pois se para este primeiro ponto o vπ(15) não pode ser alcançado pelo estado 13 então, o vπ(15) não pode ser computado. Com a alteração do estado 13 agora com a ação down indo ao 15 então este estado torna-se mais um dos estados conhecido do agente. E assim sua politica poderá ser calculada.
+```

Capítulo 5/Ex_5.01.md

@@ -0,0 +1,10 @@
+### *Exercise 5.1:*
+
+**Consider the diagrams on the right in Figure 5.1. Why does the estimated value function jump up for the last two rows in the rear? Why does it drop off for the whole last row on the left? Why are the frontmost values higher in the upper diagrams than in the lower?**
+
+---
+Resposta 1:
+
+```
+Isso ocorre pois ao esperar para dar um stick somente quando  se somar 20 ou 21, o risco de perder(bust) ao continuar pedindo cartas no resto dos valores de soma do diagrama. Já quando alcança o 20 ou 21 a vitória é bastante provável. Se o Dealer tem um Ás mostrado a política convergiu então para encontrar um empate.Por causa da condição do As usável no superior e não usavel no inferior.
+```

Capítulo 6/Ex_6.02.md

@@ -8,3 +8,10 @@ Resposta 1:
 ```
 O método TD pode usar predições do inicio ao fim de experiências passadas. Já o método MC precisa criar predições. Dessa forma, é provável que as predições de MC sejam diferentes da realidade e por isso, o método TD é melhor nesse caso
 ```
+
+---
+Resposta 2:
+
+```
+Sim. Em um caso de troca de um braço mecânico onde já havia tido um treinamento por reforço já computado as políticas e valores. Por se tratar de um novo braço, então o TD estimaria de acordo com o anterior, e recalculada com base nas movimentações de treinamento e execução. No caso do monte carlo tudo isto deveria ser feito do início ao fim. Sim, de fato poderia ocorrer no cenário original.
+```

Capítulo 7/Ex_7.03.md

@@ -0,0 +1,10 @@
+### *Exercise 7.3:*
+
+**Why do you think a larger random walk task (19 states instead of 5) was used in the examples of this chapter? Would a smaller walk have shifted the advantage to a different value of n? How about the change in left-side outcome from 0 to −1 made in the larger walk? Do you think that made any difference in the best value of n?**
+
+---
+Resposta 1:
+
+```
+As diferenças que seriam encontradas nos valores de n e α são menores em um random walk com 5 estados que com 19. Com um n<4 o random walk com 5 steps pode conseguir valores melhores. Se for mudado a recompensa do lado esquerdo para -1 e o valor inicial permanecer o mesmo então o valor inicial será mais otimista.
+```

Capítulo 8/Ex_8.02.md

@@ -8,3 +8,10 @@ Resposta 1:
 ```
 O algoritmo Dyna Q por ser menos exploratório, na primeira fase, pode ter encontrado um caminho não ótimo para chegar ao estado terminal  e continuou a seguir esse caminho por mais tempo do que no algoritmo Dyna Q+, que possui uma exploração do ambiente maior, consequentemente atingindo mais rapido a política ótima. Já na segunda fase, no primeiro experimento, acontece algo similar a primeira fase, no bloqueio do caminho, os dois algoritmos encontram o caminho ótimo, porém o Dyna Q+ o encontra mais rapidamente. No segundo experimento, na abertura de um novo caminho, o Dyna Q+ encontra a política ótima pela sua natureza mais exploratória, enquanto o Dyna Q continua indo pelo caminho não otimo, justamente por causa da sua natureza pouco exploratória, mesmo utilizando e-greedy. 
 ```
+
+---
+Resposta 2:
+
+```
+Porque essa exploração é realizada com base em um registro para cada par estado-ação das etapas de tempo decorridas desde a última tentativa do par em uma interação real com o ambiente. Então quando o ambiente se move o Dina-q+ tenta por meio da exploração esse par de ação tentado a muito tempo sem sucesso e acaba por encontrar  a saida. Onde o Dyna-q não explora e acaba por se prender a politica anterior e ter que atualiza-la toda novamente.
+```

Capítulo 9/Ex_9.04.md

@@ -0,0 +1,10 @@
+### *Exercise 9.4:*
+
+**Suppose we believe that one of two state dimensions is more likely to have an effect on the value function than is the other, that generalization should be primarily across this dimension rather than along it. What kind of tilings could be used to take advantage of this prior knowledge?**
+
+---
+Resposta 1:
+
+```
+Poderia ser usado a Log Stripes que promove a generalização ao longo da dimensão que acredita-se ser a mais eficaz para a função valor. Ou então usaria-se o Diagonal Stripes pois este promove a generalização a longo de uma diagonal desta forma ignorando algumas dimensões
+```