O Algoritmo factRTDP-IP - Programação dinâmica em tempo real para processos de decisão markovia

Baseado nas soluções assíncronas fatoradas para MDPs (Holguin,2013), o algoritmo factRTDP- IP combina as idéias do SPUDD-IP (Delgado et al.,2011) (Seção5.2.2) e do RTDP-IP (Seção6.1).

factRTDP-IP Update Assim como o RTDP, o Bellman update é realizado somente para o estado que está sendo visitado no trial, conforme a seguinte Equação:

Vt+1(⃗x) = min

a∈A

{

6.3 O ALGORITMO FACTRTDP-IP 47

Algoritmo 15: LRTDP-IP(V0_{, SSP M DP} _{− IP, maxtime, ϵ) → V}

início

// Inicializa V com uma função valor admissível V0

V := V0

// O CredalSetVerticesHash mapeia cada conjunto credal para os seus vértices

CredalSetVerticesHash := ∅

// Calcula os vértices e os pontos aleatórios de todos os conjuntos credais se necessário

6 se (predened_parameter_choice) então 7 CredalSetVerticesHash := ComputeAllCredalSetVertices () 8 ⃗ p :=ComputeRandomPointForAllCredalSets ( 9 CredalSetVerticesHash)

enquanto (não excedeu maxtime ∧ ¬s0.Solved()) faça

visited.Clear() // Limpa a pilha de estados visitados

s := s0

enquanto (¬s.Solved()) faça

13 visited.Push(s) 14 se (s ∈ G) então 15 break 16 17 ⟨V (s), ⃗p′_{⟩ := s.RTDP-IP-Update(V )} 18 se (minimax_parameter_choice) então 19 ⃗ p := ⃗p′ 20 a := s.GreedyAction(V ) 21 s := s.RTDP-IP-Sampling(a, ⃗p) 22 23

// Verica a convergência dos estados

enquanto (¬visited.Empty()) faça

25 s :=visited.Pop() 26 se (¬s.CheckSolved-IP(V, ϵ)) então 27 break 28 29 30 retorna V 31 m 32 em que

Qt+1(⃗x, a) = EvalP ADD(CDD( ⃗X, a), ⃗x)⊕

max ⃗ p∈Ka ∑ x′₁,···x′n n ⊗ i=1

(pEvalP ADD(PDD(Xi′|paa(Xi′), a), ⃗x))⊗ VDDt ( ⃗X′) . (6.5)

Note que, após calcular a Equação (6.5) Qt+1_(⃗_{x, a)} _{e V}t+1_(⃗_x) _{viram valores reais, de forma}

diferente da ADD resultante calculada pelo backup do SPUDD-IP (Equações 5.7 e 5.8), em que

Qt+1_DD( ⃗X, a)e V_DDt+1( ⃗X)são ADDs representando os valores correspondentes para o conjunto completo

de estados. Isto ocorre devido ao algoritmo explorar o espaço de estados em trials e realizar Bellman updates somente para o estado atualmente visitado, fazendo com que seja obtido somente o valor constante Vt+1 _{para o estado ⃗x.}

Como no SPUDD-IP, o cálculo da Equação (6.5) pode ser realizada de forma eciente eliminando uma variável de cada vez, desde que ela não dependa de outra variável. Por exemplo, se X′

1 não é dependente de outra X′

i,∀i ̸= 1 utilizando a ação a, é possível empurrar a soma sobre X1′ para dentro, expandindo a Equação (6.5) em:

Figura 6.3: PADD resultante da operação pEvalP ADD(PDD(Xi′|paa(Xi′), a), ⃗x).

Figura 6.4: Eliminação de variáveis no factRTDP-IP.

Qt+1(⃗x, a) = EvalP ADD(CDD( ⃗X, a), ⃗x)⊕

max ⃗ p∈Ka ∑ x′₁,··· ,x′n n ⊗ i=2

pEvalP ADD(PDD(Xi′|paa(Xi′), a), ⃗x)⊗

∑

⃗ x1′

pEvalP ADD(PDD(X1′|paa(X1′), a), ⃗x)⊗ VDDt ( ⃗X′), (6.6)

que pode ser repetida para todas as variáveis, obtendo:

Qt+1(⃗x, a) = pEvalP ADD(CDD( ⃗X, a), ⃗x)⊕

max

⃗ p∈Ka

∑

pEvalP ADD(PDD(Xn′|paa(Xn′), a), ⃗x)⊗

· · ·

∑

⃗ x2′

pEvalP ADD(PDD(X2′|paa(X2′), a), ⃗x)⊗ ∑

⃗ x1′

pEvalP ADD(PDD(X1′|paa(X1′), a), ⃗x)⊗ VDDt ( ⃗X′). (6.7)

Como X′

i representa uma variável Xi no próximo estado e paa(Xi′) os pais de Xi′,

pEvalP ADD(PDD(Xi′|paa(Xi′)), ⃗x), que aplica a operação de restrição para cada variável de estado,

resulta em um PADD mostrado na Figura6.3, com uma única variável X′ i.

A Figura 6.4 mostra como a eliminação de variável ocorre (considerando a ordem topológica das variáveis X′

i). Um exemplo desta operação pode ser visto na Figura 6.5 para o estado vi-

sitado ⃗x = {X1 = 1, X2 = 1} e a ação a. A Figura 6.5a mostra o produto entre a primeira função valor V0

DD( ⃗X′) (obtida após colocar linha as variáveis de VDD0 ( ⃗X)) e as probabilidades

de transição para X′

1 dado o estado atual ⃗x (i.e., o PADD resultante após aplicar a operação

pEvalP ADD(PDD(X1′|paa(X1′), a), ⃗x)); Na Figura 6.5b, com o resultado do último produto, a variável X′

6.3 O ALGORITMO FACTRTDP-IP 49

Figura 6.5: Exemplo das operações de PADD para calcular a Equação (6.7) para o estado visitado ⃗x =

{X1= 1, X2= 1} e a ação a.

pode ser eliminada multiplicando o resultado anterior pelas probabilidades de transição de X′

2 dado o estado atual ⃗x e a ação a (Figura 6.5c). Finalmente, na Figura 6.5d a marginalização sobre

x′2. é aplicada. Note que a PADD resultante corresponde a um polinômio multilinear. Isso é impor-

tante pois para realizar otimizações multilineares existem implementações ecientes que podem ser utilizadas na prática.

Em seguida, para realizar a maximização sobre os parâmetros na Equação (6.5), a operação Max- ParameterOut é aplicada. Note que maximizar os parâmetros em PADDs é equivalente a maximizar parâmetros nas folhas. Ela é realizada através da chamada de um solver não linear para uma folha no PADD, que resulta em um ADD com uma folha, i.e., que corresponde a um valor real. Para o exemplo mostrado na Figura6.5, o solver é chamado para (1−p12)(1−p24)(Figura6.5d) e para o conjunto de restrições φ, retornando os valores {p11= 0, p12= 0.8, p21= 0.5, p22= 0.5, p23= 0.25, p24= 0.15} e o valor do polinômio. Esse valor é usado com EvalP ADD(CDD( ⃗X, a), ⃗x)para calcular Qt+1(⃗x, a).

Finalmente, na Equação (6.4) a minimização sobre os valores de Qt+1 _{para todas as ações é}

realizada, resultando na constante Vt+1_{, que o factRTDP-IP insere na função valor atual V}t DD para

obter Vt+1

DD . Esta inserção é feita construindo um ADD de função indicador ⃗xDD que tem o valor 1

para o estado ⃗x e 0 para os outros, i.e., dado a atribuição de variáveis ⃗v:

EvalADD(⃗xDD, ⃗υ) =

{

1 if ⃗υ = ⃗x

0 caso contrário. (6.8)

Uma maneira de construir a função indicadora ⃗xDD é utilizar a operação de produto sequencial

⊗n

i=1XiDD, em que XiDD é o PADD de uma variável:

(xi) (1− xi)

que associa xi para a ramicação verdadeira e (1 − xi) para a ramicação falsa.

Assim, o valor Vt+1_(⃗_x) _{pode ser mascarado na antiga função valor V}t

DD( ⃗X) para se obter a

função atualizada Vt+1

DD( ⃗X)através do cálculo V t

Figura 6.6: Inserção de Vt+1_(⃗_x) _{em V}t

DD( ⃗X): o novo valor 2.25 para o estado ⃗x = {X1 = 1, X2 = 1}

calculado pela Equação (6.4), dado que o antigo valor era 2. a) Calcula o produto da diferença entre Vt+1_(⃗_x)

e Vt_(⃗_x) _{e a função indicadora ⃗x}

DD que tem o valor 1 para o estado ⃗x e 0 para os demais. b) Obtém o

resultado e soma com a antiga função valor Vt

DD( ⃗X). c) Por m, V t+1

DD ( ⃗X), o ADD resultante de calcular

DD⊕ ((Vt+1(⃗x)− Vt(⃗x))⊗ ⃗xDD).

na Figura6.6. Nesta notação é utilizado DD para funções representadas por ADDs e por PADDs;

⃗

x para representar um estado e ⃗X para representar um vetor com variáveis de estado binárias.

Amostragem de estados no factRTDP-IP Nesta operação, os métodos apresentados na Seção

6.1são novamente considerados para se escolher o valor dos parâmetros de probabilidade, i.e., mi- nimax_parameter_choice, predened_parameter_choice e rand_parameter_choice. Note que para o segundo e o terceiro método, como feito na Seção 6.1.1, é necessário calcular os vértices dos conjuntos credais de transição fatorados. Após obter os valores para ⃗p, o factRTDP-IP realiza a amostragem de cada variável X′

i do próximo estado baseados no CPT da ação a escolhida, i.e.:

⃗

x.NextStateVar(Xi′, a, ⃗p) = x′i∼ P (·|⃗x, a), (6.9)

em que a distribuição de probabilidades P (·|⃗x, a) é obtida a partir das folhas do ADD retornado por V alP ADDLeaves(pEvalP ADD(PDD(Xi′|paa(Xi′), a), ⃗x), ⃗p).

Note que este ADD tem uma única variável X′

i (i.e., o resultado da avaliação de PDD com as

atribuições de variáveis ⃗x e os parâmetros de probabilidade ⃗p). A Figura 6.7 mostra um exemplo do processo de escolha do próximo estado ⃗x′_{, dado que o estado atual é ⃗x = {X1} _{= 1, X2} _{= 1}_}

e os valores de parâmetros escolhidos são p11 = 0, p12 = 0.8, p21 = 0.5, p22 = 0.5, p23 = 0.25 e

p24= 0.15. A Figura 6.7mostra como amostrar as variáveis X1′ e X2′.

O algoritmo factRTDP-IP (Algoritmo 16) inicializa VDD como um ADD com uma função

valor admissível e realiza uma série de trials que vão até atingir um estado meta. Para cada estado visitado, o algoritmo factRTDP-IP-Update é chamado (Algoritmo 16, Linha 16) retornando a função valor atualizada e os valores dos parâmetros que podem ser reusados pelo método mini- max_parameter_choice. Após escolher a ação gulosa (Algoritmo 16, Linha 19), a amostragem do

6.3 O ALGORITMO FACTRTDP-IP 51

Figura 6.7: Amostragem do factRTDP-IP para as variáveis de estado X′

1 e X2′ dado o estado

atual visitado ⃗x = {X1 = 1, X2 = 1} e os valores para os parâmetros ⃗p. a) Aplicação de

V alP ADD(pEvalP ADD(PDD(X1′|X1, a1), ⃗x), ⃗p) e amostragem do valor para X1′ com 0.2 para X1′ = 1

e 0.8 para X′

1= 0. b) V alP ADD(pEvalP ADD(PDD(X2′|X1, X2, a1), ⃗x), ⃗p) e amostragem de X2′ com 0.85

para X′

1= 1 e 0.15 para X2′ = 0.

Algoritmo 16: factRTDP-IP(V0

DD, F actSSP M DP − IP, maxtime) → VDD

início

// Inicializa VDD com uma função valor admissível V0

VDD:= VDD0

// O CredalSetVerticesHash mapeia cada conjunto credal para os seus vértices

CredalSetVerticesHash := ∅

// Calcula os vértices e os pontos aleatórios de todos os conjuntos credais se necessário

6 se ( predened_parameter_choice) então 7 CredalSetVerticesHash := ComputeAllCredalSetVertices () 8 ⃗ p :=ComputeRandomPointForAllCredalSets ( 9 CredalSetVerticesHash) 10

enquanto (não excedeu maxtime) faça

visited.Clear() // Limpa a pilha de estados visitados

12 ⃗ x := ⃗x0 13 enquanto (⃗x /∈ G) faça 14 visited.Push(⃗x) 15 ⟨VDD(⃗x), ⃗p′⟩ := ⃗x.factRTDP-IP-Update(VDD) 16 se ( minimax_parameter_choice) então 17 ⃗ p := ⃗p′ 18 a := ⃗x.GreedyAction(VDD) 19 ⃗ x := ⃗x.factRTDP-IP-Sampling(a, ⃗p) 20 21

enquanto ¬visited.Empty() faça

22 ⃗ x :=visited.Pop() 23 ⟨VDD(⃗x), ⃗p′⟩ := ⃗x.factRTDP-IP-Update(VDD) 24 25 retorna VDD 26 m 27

próximo estado é realizada (Algoritmo 16, Linha 20). Da Linha 22 a 25, o algoritmo atualiza todos os estados visitados em um trial em ordem reversa (do estado nal ao estado inicial).

Algoritmo 17: factRTDP-IP-Update(Vt

DD, ⃗x) −→ (VDDt+1, ⃗p) início

para todo a ∈ A faça

// Multiplica cada CPT em Vt

DD(⃗x′) e aplica o sum out

3 QaDD:=ConvertToPrimes(V t DD) 4 para todo X′ i em QaDD faça 5 QaDD:= Q a

DD⊗ pEvalP ADD(PDD(Xi′|paa(Xi′), a), ⃗x)

6 Qa DD:= ∑ x′_i∈X_i′Q a DD 7

//chama o solver não-linear para cada folha do PADD (aqui o PADD tem apenas uma folha)

⟨Qa

DD, ⃗pa⟩ := MaxParameterOut (QaDD,φ)

QaDD:= EvalP ADD(CDD( ⃗X, a), ⃗x)⊕ Q a DD

// Obtem um valor atualizado v para ⃗x e o insere em Vt DD

a := arg min_a_∈A[Qa

DD] 12 Vt+1:= mina∈A[QaDD] 13 V_DDt+1:=factRTDP-IP-MaskedVintoADD(VDDt , ⃗x, V t+1 ) 14 retorna (Vt+1 DD ,⃗pa) 15 m 16 Algoritmo 18: factRTDP-IP-MaskedVintoADD(Vt DD, ⃗x, Vt+1 ) −→ V t+1 DD início 1 Vt:= EvalADD(VDDt , ⃗x) 2 ⃗xDD := ⊗n i=1XiDD 3 VDDt+1:= V t DD⊕ ((Vt+1− Vt)· ⃗xDD) 4 return Vt+1 DD 5 m 6 Algoritmo 19: factRTDP-IP-Sampling(a, ⃗p) −→ ⃗x′ início 1

// Amostra cada variável de estado X′

i do próximo estado da DCN

//⃗p inicia com minimax_parameter_choice ou predened_parameter_choice

3 para todo X′ i faça 4 se (rand_parameter_choice) então 5 se (CredalSetVerticesHash.Get(⟨X′

i, ⃗x(paa(Xi)), a′ ⟩)= NULL) então

CredalSetVertices := ComputeCredalSetVertices (X′

i, ⃗x(paa(Xi′)), a)

CredalSetVerticesHash.Insert(⟨X′

i, ⃗x(paa(Xi)), a′ ⟩, CredalSetVertices)

8 9

⃗

p :=ComputeRandomPointCredalSet (

Xi′, ⃗x(paa(Xi′)), a,CredalSetVerticesHash)

x′i:= ⃗x.NextStateVar (Xi′, a, ⃗p) // De acordo com a Equação (6.9)

12 m 13 retorna ⃗x′_{:= (x}′ 1, . . . , x′n) 14

o estado ⃗x da seguinte forma: após colocar linha as variáveis de Vt

DD (Algoritmo 17, Linha 4,

que converte cada Xi em Xi′), QaDD é derivado através do cálculo da Equação (6.5) em termos

de operações de PADD (Algoritmo 17, Linhas 5-7). Após aplicar a operação MaxParameterOut (Algoritmo 17, Linha 9) o resultado obtido é um valor real. O cálculo de Vt+1_(⃗_x) _{produz uma}

constante Vt+1 _{para um ⃗x conhecido (Algoritmo} ₁₇_{, Linha 13), então o factRTDP-IP insere esta}

nova constante Vt+1 _{na função valor atual V}t

DD para obter V t+1

DD chamando o método factRTDP-

IP-MaskedVintoADD (Algoritmo18).

O algoritmo factRTDP-IP-Sampling (Algoritmo 19) amostra o próximo estado ⃗x′ _{dado o}

estado atual ⃗x, a ação a e o parâmetro ⃗p. Para escolher os valores para os parâmetros ⃗p um dos seguintes métodos é utilizado: minimax_parameter_choice, predened_parameter_choice ou

6.5 O ALGORITMO FACTLRTDP-IP 53

rand_parameter_choice.

Caso a escolha seja o método minimax_parameter_choice, ⃗p terá os mesmos valores que fo- ram calculados para a ultima atualização. Caso seja o método predened_parameter_choice, ⃗p é calculado somente uma vez no inicio do Algoritmo 16 (Linhas 7-9) calculado primeiro os vér- tices de todos os conjuntos credais (armazenados em uma tabela hash chamada CredalSetVerti- cesHash), e então utilizando estes vértices para gerar os pontos aleatórios. Por m, caso o método rand_parameter_choice tenha sido escolhido, ⃗p é calculado para as tuplas ⟨X′

i, ⃗x(paa(Xi′)), a⟩ com

i = {1, · · · , n}, onde a é a ação gulosa atual e ⃗x(paa(Xi′)) indica os valores dos pais de Xi′ na

atribuição de variáveis ⃗x, i.e., a conguração dos pais de X′

i no estado atual ⃗x (Algoritmo 19,

Linhas 5-10). Note que o tamanho de CredalSetVerticesHash será o número de conjuntos credais para o método predened_parameter_choice e será menor ou igual a este número para o método rand_parameter_choice considerando que nem todos os estados serão visitados. Assim, no pior caso o tamanho será igual a |K|max (Equação5.3). Considerando que estão sendo utilizadas variáveis bi-

nárias e assumindo conjuntos credais fechados e convexos, o número de vértices para cada conjunto credal é igual a 2. Assim o espaço requerido pela tabela CredalSetVerticesHash é proporcional a uma constante vezes |K|max.

Após denir os valores para ⃗p a amostragem é realizada para cada variável X′

i do próximo

estado (Algoritmo 19, Linha 12). Isto é feito utilizando o ADD (da variável X′

i) retornada por

V alP ADDLeaves(pEvalP ADD(PDD(Xi′|paa(Xi′), a), ⃗x), ⃗p), em que estão as probabilidades para

se realizar a amostragem.

No documento Programação dinâmica em tempo real para processos de decisão markovianos com probabilidades imprecisas (páginas 62-69)