O documento compara os algoritmos Q-Learning e Q-Lambda no problema do "Cliff-walking" usando C#. Q-Lambda com λ=1 teve melhor desempenho, convergindo mais rápido e obtendo maior recompensa total do que Q-Learning e Q-Lambda com outros λ valores.

1. Universidade Federal do Rio Grande do Sul - UFRGS
Programa de Pós-Graduação em Computação
Mestrado em Ciência da Computação
Disciplina: Aprendizagem de Máquina
Professor: Paulo Engel
Aluno: Mauricio Volkweis Astiazara
Comparação de Algoritmos Baseados em Q-Learning
Para comparar dois algoritmos de aprendizagem baseados em Q-Learning foi utilizado o
problema do “Penhasco” (Cliff-walking). Neste problema, um agente situado numa grade deve
aprender a sair de uma célula inicial e chegar a uma célula final utilizando quatro ações possível:
mover-se para cima, mover-se para baixo, mover-se para direita e mover-se para esquerda. No
caminho existem alguma células que presentam um penhasco. Caso o agente “caia” no penhasco,
ele volta a célula inicial. A medida que o agente atua no ambiente, recebe recompensas (ou
reforços). As recompensas negativas podem ser interpretadas como punições. O agente recebe como
recompensa por chegar a célula final o valor zero. Por andar em outras células sem cair no penhasco
recebe -1. Por cair no penhasco, -100. Se o agente tentar sair dos limites da grade, ele recebe o
reforço mas fica na mesma célula. Existe um limite de passos que o agente pode dar: 100. Depois
disso, ele volta ao início. Os algoritmos implementados para serem comparados neste problema de
aprendizagem foram o Q-Learning tradicional e a derivação Q-Lambda de Watkins.
A linguagem de programação selecionada para a implementação foi C-Sharp. Foi realizada
uma modelagem conceitual da aplicação produzindo o seguinte diagrama de classes em notação
UML:
Na implementação, além dos parâmetros dos referidos algoritmos, foram tornados parâmetros
todas as especificações do problema do penhasco, tornando possível alterar valores de recompensas,
limites e também a própria grade, possibilitando assim a criação de mapas diferentes.
A seleção da ação a ser executada foi implementada em ambos os algoritmos utilizando uma

2. política épsilon-gulosa, onde épsilon representa a probabilidade do agente executar uma ação
randômica com objetivo exploratório em detrimento de uma ação gulosa (com a maior recompensa
conhecida). Se épsilon for zero o agente é totalmente guloso. Se épsilon for 1, o agente é
totalmente randômico. O código-fonte abaixo implementa esta seleção de ação.
public Acao ObterAcao(int pEstado)
{
ItensQ itens = ObterItensQ(pEstado);
ItemQ item;
if (_sorteador.NextDouble() < _epsilon)
{
item=itens.Item(_sorteador.Next(itens.Total));
}
else
{
item=itens.ObterMelhor();
}
_ultimoSelecionado = item;
return item.Acao;
}
Para o algoritmo Q-Learning, a atualização da tabela Q foi implementada através do código-
fonte abaixo:
public void ReceberRecompensa(double pRecompensa, int pNovoEstado)
{
ItensQ futuro = ObterItensQ(pNovoEstado);
_ultimoSelecionado.Recompensa = _ultimoSelecionado.Recompensa
+ _alfa *
(pRecompensa
+ _gama * futuro.ObterMelhor().Recompensa
- _ultimoSelecionado.Recompensa);
}
Para o algoritmo Q-Lambda, a atualização da tabela Q foi implementada através do código-
fonte abaixo:
public void ReceberRecompensa(double pRecompensa, int pNovoEstado)
{
_proximoEstado = pNovoEstado;
// a = _ultimoSelecionado
// a' = aLinha
// a* = aOtimo
ItemQ aLinha = ObterAcaoPolitica(pNovoEstado);
ItensQ futuro = _q.Item(pNovoEstado);
ItemQ aOtima = futuro.ObterMelhor();
double Sigma = pRecompensa
+ _gama * aOtima.Recompensa
- _ultimoSelecionado.Recompensa;
_ultimoSelecionado.Erro++;
foreach (ItensQ itens in _q)
{
foreach (ItemQ item in itens)
{
item.Recompensa = item.Recompensa
+ _alfa * Sigma * item.Erro;
if (aLinha == aOtima)
{
item.Erro = _gama * _lambda * item.Erro;
}
else
{
item.Erro = 0;
}
}

3. }
_proximaAcao = aLinha;
}
Foram realizadas 10 execuções dos algoritmos com as seguintes configurações: Q-Learning,
Q-Lambda com lambda = 1, Q-Lambda com lambda = 3 e Q-Lambda com lambda = 7. Os demais
parâmetros foram iguais para todas as execuções, com os valores épsilon=0,001, alfa=0,5 e
gama=0,5. O total de recompensa e o episódio médio de convergência para cada configuração são
mostrados na tabela abaixo:
Configuração Total de
Recompensa
Episódio Médio de
Convergência
Q-Learning -65858 77,6
Q-Lambda com lambda = 0 -61401 78,1
Q-Lambda com lambda = 0.5 -62510 41,7
Q-Lambda com lambda = 1 -60950 29,1
Estes mesmos dados são exibidos nos gráficos abaixo:
Q-Learning Q-Lambda (0) Q-Lambda (0.5) Q-Lambda (1)
-42000
-41000
-40000
-39000
-38000
-37000
-36000
-35000
-34000
Total de Recompensa em 10 Episódios

4. Com essa amostragem, que é muito baixa (apenas 10 execuções), aparentemente pode-se
concluir que o algoritmo Q-Lambda com o parâmetro lambda = 0 possui um desempenho muito
semelhante ao Q-Learning tradicional. Mas a medida que o parâmetro lambda é aumentado, o
desempenho melhora. Com lambda = 1, o desempenho do Q-Lambda é muito superior ao Q-
Learning tradicional.
Q-Learning Q-Lambda (0) Q-Lambda (0.5) Q-Lambda (1)
0
10
20
30
40
50
60
70
80
90
Episódio Médio de Convergência em 10 Episódios