Renato S. P. Coelho, Dra. Leliane Nunes de Barros

(1)

USO DO ERRO DE BELLMAN PARA ACELERAR A CONVERG ÊNCIA DA PROGRAMA ¸C ÃO DIN ÂMICA EM TEMPO REAL

Renato S. P. Coelho∗, Dra. Leliane Nunes de Barros†

∗_Pr´_{o Reitoria de Gradua¸}_c˜_{ao – USP}

Rua da Reitoria, Favo 22 - Cidade Universit´aria – S˜ao Paulo – SP – Brasil

†_{Instituto de Matem´}_{atica e Estatistica – USP}

Rua do Matão, 1010 - Cidade Universitária – São Paulo – SP – Brasil Emails: [email protected], [email protected]

Abstract— The Labeled Real-Time Dynamic Programming (LRTDP) is one of the most known and most efficient algorithms used to solve Shortest Stochastic Path (SSP) problems. This paper reviews the SSP model and the LRTDP algorithm and shows a way to improve LRTDP’s state selection. This new selection scheme speeds up LRTDP by favoring states on which the algorithm has few information.

Keywords— SSP, LRTDP, Bellman Error, Probabilistic Planning, Experimental

Resumo— O algoritmo Labeled Real-Time Dynamic Programming (LRTDP) é um dos algoritmos mais con-hecidos e eficientes para a resolu¸cão de problemas de planejamento probabil´ıstico em Inteligência Artificial mod-elados como Caminho estocástico m´ınimo. Após uma revisão do modelo e do algoritmo será introduzida uma nova técnica de escolha de estados que acelera o LRTDP ao privilegiar estados sobre os quais o algoritmo tem poucas informa¸cões.

Keywords— SSP, LRTDP, Erro de Bellman, Planejamento probabil´ıstico, Experimental

1 Introdu¸c˜ao

Um problema de planejamento em Inteligência Ar-tificial (IA) envolve a constru¸cão de um agente deve ser capaz de escolher um conjunto de a¸cões que o leve a realizar um determinado obje-tivo (Russel e Norvig, 1995). Neste trabalho serão considerados problemas em que as a¸cões do agente possuem efeitos probabil´ısticos e o objetivo é per-mitir que o agente, a partir de um estado ini-cial, alcance um estado do mundo que satisfa¸ca uma dada propriedade, com o menor custo es-perado. O modelo chamado Caminho estocástico m´ınimo (Shortest Stochastic Path - SSP) formal-iza este tipo de problema, bem como induz a cri-a¸cão de algoritmos para a sua resolu¸cão (Barto et al., 1995; Geffner e Bonet, 2003).

Um dos algoritmos mais conhecidos para a resolu¸cão de SSPs é o Labeled Real-Time Dynamic Programming (LRTDP) (Geffner e Bonet, 2003), que utiliza programa¸cão dinâmica ass´ıncrona para avaliar os estados e escolher uma pol´ıtica ótima, ou seja, uma pol´ıtica que minimize o custo esper-ado dos caminhos entre o estesper-ado inicial e os esta-dos finais (Barto et al., 1995). Para acelerar o pro-cesso de convergência para a pol´ıtica ótima, exis-tem propostas para aprimorar o LRTDP avaliando quanta informa¸cão se tem sobre cada estado e privilegiando os estados sobre os quais se tem pouca informa¸cão, e.g. Bounded Real-Time Dy-namic Programming (BRTDP) (McMahan et al., 2005) e Focused Real-Time Dynamic Program-ming (FRTDP) (Smith e Simmons, 2006). En-tretanto, estas propostas são baseadas no cálculo de um limitante superior para o valor ótimo dos

estados e este c´alculo pode envolver um alto custo computacional (McMahan et al., 2005).

Uma outra fam´ılia de algoritmos que usa pro-grama¸cão dinâmica ass´ıncrona para resolver SSPs é a fam´ılia do Prioritized Sweeping (Moore e Atkenson, 1993). Estes algoritmos utilizam o gra-diente do valor dos estados para priorizar os esta-dos que devem ser atualizaesta-dos.

Neste artigo será proposto um novo algoritmo (Gradient Oriented Labeled Real-Time Dynamic Programming - GRTDP) que aprimora o LRTDP combinando o com a idéia de privilegiar estados baseado no gradiente de sua fun¸cão valor. A vantagem deste novo algoritmo é utilizar o gra-diente do valor dos estados sem a necessidade de muitos cálculos adicionais. Esta maneira de escolher quais estados terão seus valores atual-izado deve tornar as atualiza¸cões mais eficientes e, consequentemente, diminuir o número de at-ualiza¸cões e o tempo necessário para encontrar a pol´ıtica ótima em um SSP quando comparado com o LRTDP.

Este artigo está organizado da seguinte maneira: na Se¸cão 2 vamos descrever o modelo em que estamos interessados para o planejamento em IA (SSP) e alguns dos algoritmos usados para a sua resolu¸cão, na Se¸cão 3 vamos propor um novo algoritmo para a resolu¸cão de SSPs que aprimora o LRTDP utilizando o gradiente do valor dos es-tados para escolher quais eses-tados devem ser at-ualizados e na Se¸cão 4 vamos comparar o novo algoritmo com o LRTDP em termos de eficiência e comportamento em qualquer instante.

(2)

2 Revis˜ao

Nesta se¸cão, o modelo Caminho estocástico m´ın-imo (SSP) será formalmente descrito, bem como o algoritmo Labeled Real-Time Dynamic Program-ming, que resolve SSPs. Também será feita uma breve descri¸cão do algoritmo Bounded Real-Time Dynamic Programming e dos algoritmos da fam´ılia do Prioritized Sweeping.

2.1 SSP - Shortest Stochastic Path

O modelo SSP representa uma subclasse dos problemas que podem ser descritos como MDPs (Markov Decision Processes) (Puterman, 1994; Boutilier et al., 1999). Esta subclasse é particular-mente interessante pela sua capacidade natural de modelar problemas de planejamento probabil´ıstico. Além disso, permite um ganho computacional, já que uma solu¸cão para esses problemas só precisa estar definida para os estados relevantes. Ou seja, estados que podem ser alcan¸cados a partir do es-tado inicial quando se utiliza a pol´ıtica gerada pelo agente.

Os SSPs consideram que o tempo avan¸ca em intervalos discretos e que, em cada instante de tempo o agente deve realizar uma a¸c˜ao. Formal-mente, o modelo pode ser descrito atrav´es das seguintes caracter´ısticas (Bertsekas, 1995; Geffner e Bonet, 2003):

• Um conjunto discreto e finito de estados, S. Considera-se que os estados satisfazem a hipótese de Markov, isto é, cada estado con-tém toda a informa¸cão necessária para predi-zer os efeitos de todas as a¸cões e eventos, inde-pendentemente de outras informa¸cões sobre o histórico do sistema (estados visitados e a¸cões executadas no passado).

• Um estado inicial s0∈ S1.

• Um conjunto n˜ao vazio de estados meta,SG ⊆

S.

• Um conjunto de a¸c˜oes A e subconjuntos A(s) ⊆ A, para cada s ∈ S.

• Uma distribui¸c˜ao de probabilidades P (·|s, a) sobre S para cada s ∈ S e a ∈ A(s), que descreve os efeitos das a¸c˜oes.

• Um custo n˜ao negativo, c(s, a) > 0 associado a cada par estado-a¸c˜ao.

• Os estados são totalmente observáveis. Dado este problema, o objetivo de um agente é criar uma pol´ıtica que o leve do estado inicial até algum estado final com o menor custo esperado,

1_{O modelo e todos os algoritmos que aparecem neste}

ar-tigo podem facilmente ser expandidos considerando-se um conjunto S0de estados iniciais.

ou seja, com a menor média ponderada dos custos dos caminhos. Considerando este critério o valor de uma pol´ıtica ótima para um estado s, ou valor ´

otimo de um estado, pode ser dado por (Bellman, 1957): V∗(s) = min a∈A(s) (c(a, s) + X s0_∈S P (s0|s, a) ∗ V∗(s0)) (1) Como veremos a seguir, esta equa¸cão é a base para os algoritmo de programa¸cão dinâmica usa-dos em planejamento probabil´ıstico.

2.2 O algoritmo LRTDP

O Labeled Real-Time Dynamic Programming (LRTDP) (Geffner e Bonet, 2003) faz simula¸cões dos caminhos gerados a partir da execu¸cão da pol´ıtica gulosa enquanto a estimativa do valor dos estados nestes caminhos é melhorada. A idéia é parecida com um processo de treinamento. Isto é feito até que o valor ótimo (único ponto fixo da Equa¸cão 1 (Givan et al., 1997)) seja aprox-imado de maneira satisfatória. Para facilitar a computa¸cão as estimativas dos valores dos esta-dos são guardadas em uma tabela, de acordo com os preceitos da programa¸cão dinâmica. Estas es-timativas são sempre limitantes inferiores do valor ´

otimo dos estados.

O algoritmo LRTDP é composto por duas rotinas principais que se alternam. A primeira é responsável por uma atualiza¸cão ass´ıncrona dos valores dos estados, enquanto a segunda é respon-sável por testar se o valor dos estados já está aproximado de uma maneira satisfatória.

A primeira rotina (LRT DP T rial(), Algo-ritmo 1) parte do estado s0 e simula a execu¸c˜ao

de uma pol´ıtica gulosa ao mesmo tempo em que calcula esta pol´ıtica, ou seja, para cada estado s alcan¸cado, ela escolhe de maneira gulosa uma a¸cão a de acordo com os valores armazenados para os estados. O próximo estado a ser atualizado será escolhido usando-se a distribui¸cão de proba-bilidades P (·|s, a), ou seja, se P (s0|s, a) = 0, 7 a probabilidade de que o estado s0 seja o próximo estado visitado pelo algoritmo é 0, 7. Com isso, a rotina privilegia os estados que influenciam mais na fun¸cão valor. Quando o algoritmo encontra um estado pertencente a SGou um estado já resolvido,

isto é, um estado cujo valor já está aproximado de maneira satisfatória, ele chama a segunda rotina para cada um dos estados que foi visitado naquela simula¸cão (por uma questão de eficiência, a rotina é chamada primeiro para os últimos estados visi-tados).

A segunda rotina (checkSolved(), Algoritmo 2) é responsável por testar se um estado s já está resolvido, isto é, se o seu valor já está aproximado de uma maneira satisfatória. Para isto, ela real-iza uma busca em profundidade em todos os

(3)

esta-dos acess´ıveis a partir do estado s (utilizando-se a pol´ıtica gulosa) até os estados meta ou os esta-dos que já estão marcados como resolvidos. Nesta busca, o valor de cada um dos estados é calcu-lado e comparado com o valor armazenado para aquele estado. A diferen¸ca entre estes dois valores é chamada de erro de Bellman. Se, para algum es-tado visies-tado na busca em profundidade o erro de Bellman for maior do que um , dizemos que o es-tado s ainda não foi resolvido2_{. Se durante a busca}

não for encontrado nenhum estado que tenha vari-ado muito seu valor, o estvari-ado s e todos os estvari-ados alcan¸cáveis a partir dele utilizando-se a pol´ıtica gulosa são marcados como resolvidos. É impor-tante notar que não é poss´ıvel criar uma fórmula fechada que relacione o valor de com a distância entre o valor final do estado marcado como re-solvido e seu valor ótimo (Geffner e Bonet, 2003). Esta rotina é bastante importante para o algo-ritmo, pois ela é responsável por fazer com que os estados que têm pouca probabilidade de serem al-can¸cados de acordo com a primeira rotina passem a ser visitados com mais frequência. A rotina LRT DP T rial() é chamada até que o estado ini-cial seja marcado como resolvido. Os Algoritmos 1 e 2 descrevem estas rotinas.

Algoritmo 1: LRTDPTrial Entrada: s0, epsilon.

s = s0 1

visitado = pilhaV azia

2

enquanto s.marcado = falso fa¸ca

3

visitado.push(s)

4

se s.meta = verdadeiro ent˜ao break

5 a = s.acaoGulosa() 6 s.update() 7 s = s.proximoEstado() 8 fim enqto 9

enquanto visitado 6= pilhaV azia fa¸ca

10

s = visitado.pop()

11

se s.checkSolved() = f also ent˜ao

12

break fim enqto

13

2.3 BRTDP

O algoritmo Bounded Real-Time Dynamic Pro-gramming (BRTDP) (McMahan et al., 2005) é similar ao LRTDP. A diferen¸ca é que o BRTDP também armazena uma estimativa que é um lim-itante superior do valor dos estados (VU_{). Junto}

com a estimativa de limite inferior do LRTDP (VL_{) o BRTDP ´}_{e capaz de: (i) direcionar a escolha}

de estados para que o algoritmo priorize estados sobre os quais tem pouca informa¸cão, (ii) testar se um estado já convergiu simplesmente calculando se a diferen¸ca entre as duas heur´ısticas é menor

2_{O valor deve ser dado como parˆ}_{ametro do algoritmo.}

Algoritmo 2: checkSolved Entrada: Um SSP, ,s

Sa´ıda: Verdadeiro se s tiver convergido, falso c.c.

resposta = verdadeiro

1

aberto = P ilhaV azia

2

f echado = P ilhaV azia

3

se ¬s.M arcado ent˜ao aberto.push(s)

4

enquanto aberto 6= P ilhaV azia fa¸ca

5 s = aberto.pop() 6 f echado.push(s) 7 se s.erroDeBellman(a) > ent˜ao 8 resposta = f also 9 continue 10 fim se 11 //expande o estado 12 a = s.acaoGulosa() 13

para todo s0 tal que P (s0|s, a) > 0

14

fa¸ca

se ¬s0_{.M arcado e ¬Em(s}0_{, aberto ∪} 15 f echado) ent˜ao aberto.push(s0) 16 fim se 17

fim para todo

18

se resposta = verdadeiro ent˜ao

19

//marca os estados alcan¸c´aveis a

20

partir da pol´ıtica gulosa para todo s ∈ f echado fa¸ca

21

s.M arcado = verdadeiro

22

fim para todo

23

fim se

24

sen˜ao

25

enquanto f echado 6= P ilhaV azia

26 fa¸ca s = f echado.pop() 27 s.update() 28 fim enqto 29 fim se 30 fim enqto 31 Resultado: resposta

do que a tolerância especificada. Com esta infor-ma¸cão é poss´ıvel determinar o quanto o valor de um estado está próximo de seu valor ótimo.

Este algoritmo tem se mostrado muito efi-ciente, principalmente em dom´ınios onde há muitas transi¸cões de baixa probabilidade, uma vez que o algoritmo poderia deixar de visitar muitos estados relevantes nestes dom´ınios. Entretanto, o custo para calcular uma estimativa superior para o valor dos estados é muito alto e este cálculo pode fazer com que o BRTDP apresente um de-sempenho ruim para problemas grandes. O Algo-ritmo 3 mostra o pseudo-código da fun¸cão princ´ı-pal do BRTDP. Ela é chamada até que a diferen¸ca entre as duas heur´ısticas seja suficientemente pe-quena para o estado inicial.

(4)

Algoritmo 3: BRTDPTrial Entrada: s0, τ .

s = s0 1

2

enquanto verdadeiro fa¸ca

3

visitado.push(s)

4

// VU _´_{e a estimativa superior para o} 5

valor dos estados e VL a estimativa inferior VU(s) = s.updateVU() 6 a = s.greedyAction() 7 VL_{(s) = s.updateV}L₍₎ 8

para todo s0∈ S fa¸ca

9

b(s0) = (VU_(s0_{) − V}L_(s0_{)) ∗ P (s}0_{|s, a)} 10

fim para todo

11 B =P s0_∈Sb(s0) 12 se B < ((VU_(s 0) − VL(s0))/τ ) ent˜ao 13 break 14

s ´e escolhido de acordo com a

15

distribui¸c˜ao b(s0)/B fim enqto

16

17 s = visitado.pop() 18 VU_{(s) = s.updateV}U₍₎ 19 VL(s) = s.updateVL() 20 fim enqto 21

State :: updateVL_{() atualizam,}

respectiva-mente, as estimativas superiores e inferiores dos estados. A primeira devolve o valor da equa¸c˜ao mina∈A(s)(c(a, s) + Ps0_∈SP (s0|s, a) ∗ VU(s))

e a segunda devolve o valor da equa¸c˜ao mina∈A(s)(c(a, s) +

P

s0_∈SP (s0|s, a) ∗ VL(s)).

A a¸cão gulosa é escolhida de acordo com VL. Segundo McMahan et al. (2005) o critério de parada das itera¸cões (neste caso, B < ((VU(s0) − VL(s0))/τ )) tem pouca influˆ

en-cia no tempo de execu¸c˜ao do algoritmo.

2.4 Prioritized Sweeping

O algoritmo de Moore e Atkenson (1993) não foi originalmente proposto para ser utilizado em problemas de planejamento, mas sim em apren-dizado computacional. Entretanto, novos algo-ritmos surgiram baseados nesta idéia, i.e. pri-orizar os estados segundo o erro de Bellman de seus sucessores. Exemplos destes algoritmos são os General Prioritized Solvers propostos por Wingate e Seppi (2005). Nestes algoritmos as it-era¸cões come¸cam a partir de algum predecessor de um estado meta e toda vez que um estado é atu-alizado, e seu erro de Bellman é maior do que um dado valor, os seus predecessores são armazenados em uma lista de prioridades (a sua prioridade é calculada usando alguma métrica baseada no erro de Bellman). A lista de prioridades define qual o próximo estado a ser atualizado. Um algoritmo

mais recente dessa fam´ılia, Backward Value Itera-tion) (Dai e Hansen, 2007), propõe que não se use uma lista de prioridades, mas apenas uma lista. Todos os estados que são predecessores de estados que quando atualizados tem um erro de Bellman maior do que um dado são postos nessa lista.

Uma das limita¸cões destes algoritmos é as-sumir que a matriz de transi¸cão está completa-mente dispon´ıvel e pode ser transposta facilcompleta-mente. Ou seja, esses trabalhos assumem um modelo de estados descrito explicitamente. No entanto, esta suposi¸cão não deve ser feita quando se deseja re-solver problemas grandes (principalmente quando o número de estados relevantes é pequeno em re-la¸cão ao número total de estados). Essa suposi¸cão não é feita pelos algoritmos da fam´ılia do RTDP (Algoritmos 1 e 3).

Na próxima se¸cão apresentaremos um algo-ritmo que combina as vantagens do LRTDP com a idéia do Prioritized Sweeping.

3 GRTDP

A idéia do algoritmo proposto neste artigo (Gra-dient Oriented Labeled Real-Time Dynamic Pro-gramming - GRTDP) é modificar o LRTDP dire-cionando a escolha dos estados que devem ser at-ualizados privilegiando os estados sobre os quais o algoritmo tem poucas informa¸cões, de maneira similar a proposta do BRTDP. Para fazer isso sem muitas computa¸cões adicionais, ainda que uti-lizando um pouco mais de memória, o algoritmo utiliza o erro de Bellman (gradiente da fun¸cão valor) na escolha dos estados. Esta mudan¸ca tem como objetivo melhorar a qualidade da in-forma¸cão utilizada nas próximas atualiza¸cões.

No GRTDP, as fun¸cões utilizadas no LRTDP permanecem iguais, com exce¸cão da fun¸cão Estado :: proximoEstado(), que passa a usar uma nova distribui¸cão de probabilidades para a escolha dos estados. Esta nova distribui¸cão de probabilidades é dada pelo valor normalizado de P (s0_{|s, a)∗E(s}0_{), em que E(s}0_{) ´}_{e o erro de Bellman}

do estado s0, armazenado na última vez em que o valor de s0 foi atualizado. Além disso, há uma mudan¸ca na fun¸cão LRT DP T rial() para maxi-mizar o fluxo de informa¸cões. Quando a fun¸cão está checando se os estados convergiram e encon-tra um estado que ainda não convergiu ela para de testar a convergência dos estados visitados, mas continua atualizando seus valores. O Algoritmo 4 mostra a nova fun¸cão GRT DP T rial().

A primeira altera¸cão indica os estados sobre os quais o algoritmo tem pouca informa¸cão, ou tinha pouca informa¸cão até a última atualiza¸cão e assim estes estados podem ser privilegiados. Com isso, as atualiza¸cões se tornam mais eficientes, uma vez que os próximos estados a serem atualiza-dos utilizarão valores melhor aproximados. Esta maneira de medir quanta informa¸cão se tem sobre

(5)

Algoritmo 4: GRTDPTrial Entrada: s0, epsilon.

s = s0 1

2

enquanto s.marcado = falso fa¸ca

3

visitado.push(s)

4

se s.meta = verdadeiro ent˜ao break

5 a = s.acaoGulosa() 6 s.update() 7 s = s.proximoEstado() 8 fim enqto 9 f lag = f also 10

11

s = visitado.pop()

12

se f lag = verdadeiro ent˜ao

13

s.update()

14

sen˜ao se s.checkSolved() = f also

15 ent˜ao f lag = verdadeiro 16 fim se 17 fim enqto 18

um estado não é tão precisa quanto a diferen¸ca entre as estimativas utilizada no BRTDP, mas é muito mais fácil de ser calculada. A segunda at-ualiza¸cão permite que quando há uma mudan¸ca grande no valor de um estado (maior do que ) essa informa¸cão seja propagada.

4 Resultados

Para testar o desempenho do GRTDP frente ao LRTDP implementamos o GRTDP no sistema miniGPT (Bonet e Geffner, 2005). Sistema us-ado pelos autores do LRTDP na competi¸cão Inter-national Planning Competition de 2004 (IPC’04). Esse sistema funciona em conjunto com o sis-tema mdpsim utilizado na competi¸cão para simu-lar a execu¸cão das pol´ıticas devolvidas pelos plane-jadores. Testamos quatro problemas da com-peti¸cão, dois do famoso dom´ınio blocksworld e dois do dom´ınio schedule. Cada planejador resolveu os problemas 5 vezes e os resultados apresentados são a média do consumo de tempo gasto pelos plane-jadores.

bw1 bw2 sc1 sc2

LRTDP 15456,6 14049,8 128,4 5098036,4 GRTDP 8294,8 9505,8 77,4 4182632,4

% 53,66 67,66 60,28 82,04

Tabela 1: Consumo médio de tempo para a res-olu¸cão dos quatro problemas usando a heur´ıstica ’atom-min-1-forward’ e = 0.0001. A última linha mostra a porcentagem do tempo gasto pelo GRTDP em rela¸cão ao tempo gasto pelo LRTDP. Na Tabela 1 podemos ver que o GRTDP foi bem mais rápido que o LRTDP para todas as

in-stˆancias consideradas (o GRTDP chegou a gastar 47% menos tempo). Com isso podemos perceber que a nova maneira de escolher quais estados de-vem ser atualizados proporciona resultados mel-hores e que, como ela exige pouco processamento o tempo gasto para calcular esta nova prioridade ´e compensado.

Os problemas retirados do conjunto de testes do IPC’04 foram: bw 5 30906 (bw1 ), bw 5 14257 (bw2 ), problem410 (sc1 ) e a-schedule-problem74 (sc2 ). Em todos os testes usamos a heur´ıstica ’atom-min-1-forward’ (Haslum and Geffner, 2000).

Por falta de tempo não foi poss´ıvel realizar uma implementa¸cão do BRTDP para compar´ a-lo diretamente com o GRTDP. Entretanto, pode-mos fazer uma compara¸cão indireta, que, apesar de não ser muito precisa, pode nos indicar como o GRTDP se comporta em rela¸cão ao BRTDP. No artigo que apresenta o BRTDP (McMahan et al., 2005) podemos ver que o algoritmo é muito mais rápido que o LRTDP quando o dom´ınio têm muitas transi¸cões de baixa probabilidade, já que o BRTDP pode não visitar todos os estados rel-evantes. No artigo foram feitos dois testes em dom´ınios que não apresentam esta caracter´ıstica em um dos testes o BRTDP foi aproximadamente três vezes mais rápido que o LRTDP no outro teste o BRTDP foi aproximadamente três vezes mais lento que o LRTDP. Assim, como o GRTDP apre-sentou resultados consistentemente melhores que o LRTDP em todos os testes, vemos que os resul-tados são comparáveis aos resultados obtidos pelo BRTDP.

5 Conclus˜oes

Neste artigo foi proposta uma modifica¸cão do al-goritmo LRTDP com rela¸cão a maneira de escol-her os estados que devem ter seu valor atualizado e uma altera¸cão no fluxo da informa¸cão. Os experi-mentos mostraram que estas altera¸cões podem ter bastante influência na eficiência das atualiza¸cões e, consequentemente, no tempo necessário para re-solver problemas de planejamento probabil´ıstico modelados como SSPs.

A maneira utilizada para medir quanta infor-ma¸cão o algoritmo tem sobre os estados é par-ticularmente interessante por não utilizar muitos recursos adicionais.

Como trabalhos futuros pretendemos testar o GRTDP em outros dom´ınios para garantir que as caracter´ısticas observadas não dependem dos dom´ınios testados, bem como fazer uma imple-menta¸cão do BRTDP para que uma compara¸cão direta possa ser realizada e uma implementa¸cão de algum algoritmo da familia do Prioritized Sweep-ing, ambas no sistema miniGPT.

Esta pesquisa conta com o apoio da FAPESP atrav´es do processo 2008/04728-0.

(6)

Referˆencias

Barto, A., Bradtke, S., Singh, S. (1995). Learning to act using real-time dynamic programming, Artificial Intelligence 72:81-138.

Bellman, R.E. (1957), Dynamic Programming, Princeton University Press.

Bertsekas, D. (1995), Dynamic Programming and Optimal Control. Athena Scientific.

Bonet, B., Geffner, H. (2005), mGPT: A Proba-bilistic Planner Based on Heuristic Search, Journal of Artificial Intelligence Research 24:933-944, AAAI Press.

Boutilier, C., Dean, T., Hanks, S. (1999), Decision-Theoretic Planning: Structural As-sumptions and Computational Leverage, Journal of Artificial Intelligence Research 11, 1-94.

Dai, P., Hansen, E. A. (2007), Prioritizing Bell-man Backups Without a Priority Queue, In-ternational Conference on Automated Plan-ning and Scheduling.

Geffner, H., Bonet, B.(2003), Labeled RTDP: Im-proving the convergence of Real-Time Dy-namic Programming, Proceedings of ICAPS 2003.

Givan,R., Leach, S., Dean, T. (1997), Bounded Parameter Markov Decision Processes, Arti-ficial Intelligence 122:234-246.

Haslum, P., Geffner, H. (2000), Admissible Heuristic for Optimal Planning, Proceedings of the Artificial Intelligence Planning Sys-tems 2000, 140-149.

McMahan, H.B., Likhachev, M., Gordon, G.J. (2005), Bounded real-time dynamic program-ming: RTDP with monotone upper bounds and performance guarantees, Proceedings of the 22nd international conference on Ma-chine learning, 569-576.

Moore, A., Atkenson, C. (1993), Prioritized Sweeping: Reinforcement Learning with less data and less real time, Machine Learning Journal 13:103-130.

Puterman, M. (1994), Markov Decision Processes - Discrete Stochastic Dynamic Programming, John Wiley and Sons, Inc..

Russell, S., Norvig, P. (1995), Artificial Intel-ligence: A Modern Approach, Prentice Hall Series in Artificial Intelligence, Englewood Cliffs, New Jersey.

Smith, T., Simmons, R. (2006), Focused Real-Time Dynamic Programing for MDPs: Squeezing More Out of a Heuristic, Proceed-ings of the National Conference on Artificial Intelligence (AAAI), Boston MA.

Wingate, D., Seppi, K. D. (2005), Prioritiza-tion Methods for Accelerating MDP Solvers, Journal of Machine Learning Research, 851-881.

Younes, H.L.S., Littman, M.L.(2003), PPDDL1.0: An extension to PDDL for expressing plan-ning domains with probabilistic effects. Tech-nical Report CMU-CS-04-167, Carnegie Mel-lon University.