Resolviendo el problema del lago congelado

usando la iteración de políticas

Imagínese, hay un lago congelado desde su casa hasta la oficina, debe caminar sobre el lago
congelado para llegar a su oficina. Pero ¡ups! habrá un agujero en el lago congelado en el medio,
por lo que debe tener cuidado al caminar en el lago congelado para evitar quedar atrapado en los
agujeros. Mire la siguiente figura donde,

1. S es la posición inicial (Casa)

2. F es el lago congelado donde puedes caminar
3. H es el Agujero con el que debes tener mucho cuidado
4. G es el objetivo (oficina)

title

Bien, ahora usemos a nuestro agente en lugar de usted para encontrar la forma correcta de llegar a
la oficina. El objetivo del agente es encontrar la ruta óptima para llegar de S a G sin quedar atrapado
en H. ¿Cómo puede lograr esto un agente? Damos +1 punto como recompensa al agente si lo hace
correctamente camina sobre el lago congelado y 0 puntos si cae en el agujero. Para que ese agente
pueda determinar cuál es la acción correcta. Un agente intentará ahora encontrar la política óptima.
La política óptima implica tomar el camino correcto que maximiza la recompensa del agente. Si el
agente está maximizando la recompensa, aparentemente el agente está aprendiendo a saltarse el
hoyo y llegar al destino.

Primero, importamos las bibliotecas necesarias

In [1]: import gym

import numpy as np

Inicializar nuestro gym environment

In [3]: env = gym.make('FrozenLake-v0')

[2023-04-17 20:36:05,450] Making new env: FrozenLake-v0

Veamos cómo se ve el entorno

In [4]: env.render()

SFFF
FHFH
FFFH
HFFG

<ipykernel.iostream.OutStream at 0x1fd52fe0df0>
Out[4]:

Ahora, calcularemos la función de valor

In [5]: def compute_value_function(policy, gamma=1.0):

# inicializar tabla de valores con ceros

value_table = np.zeros(env.nS)

# establecer el umbral
threshold = 1e-10

while True:

# copiar la tabla de valores a la tabla_valor_actualizado

updated_value_table = np.copy(value_table)

# para cada estado del entorno, seleccione la acción según la política y calcule l
for state in range(env.nS):
action = policy[state]

# construir la tabla de valores con la acción seleccionada

value_table[state] = sum([trans_prob * (reward_prob + gamma * updated_value_ta
for trans_prob, next_state, reward_prob, _ in env.P[state][action]

if (np.sum((np.fabs(updated_value_table - value_table))) <= threshold):

break

return value_table

Ahora, definimos una función llamada política de extracción para extraer la política óptima de la
función de valor óptimo. es decir, calculamos el valor Q usando nuestra función de valor óptimo y
seleccionamos las acciones que tienen el valor Q más alto para cada estado como la política óptima.

In [6]: def extract_policy(value_table, gamma = 1.0):

# Inicializar la política con ceros

policy = np.zeros(env.observation_space.n)

for state in range(env.observation_space.n):

# inicializar la tabla Q para un estado

Q_table = np.zeros(env.action_space.n)

# calcular el valor Q para todas las acciones en el estado

for action in range(env.action_space.n):
for next_sr in env.P[state][action]:
trans_prob, next_state, reward_prob, _ = next_sr
Q_table[action] += (trans_prob * (reward_prob + gamma * value_table[next_s

# Seleccione la acción que tiene el valor Q máximo como una acción óptima del esta
policy[state] = np.argmax(Q_table)

return policy

Ahora, definimos la función para realizar la iteración de políticas.

In [7]: def policy_iteration(env,gamma = 1.0):

# Inicializar política con ceros

old_policy = np.zeros(env.observation_space.n)
no_of_iterations = 200000
 for i in range(no_of_iterations):

# calcular la función de valor

new_value_function = compute_value_function(old_policy, gamma)

# Extraer nueva política de la función de valor calculado

new_policy = extract_policy(new_value_function, gamma)

# Luego, verificamos si hemos alcanzado la convergencia, es decir, si encontramos

# comparando la política anterior y la política nueva. Si es lo mismo, interrumpir

# de lo contrario, actualizaremos la política anterior con la política nueva

if (np.all(old_policy == new_policy)):
print ('La iteración de políticas convergió en el paso %d.' %(i+1))
break
old_policy = new_policy

return new_policy

In [8]: print (policy_iteration(env))

La iteración de políticas convergió en el paso 7.

[0. 3. 3. 3. 0. 0. 0. 0. 3. 1. 0. 0. 0. 2. 1. 0.]

In [ ]: