Tabla de contenido
3. Código y resultados de la simulación.
3.1 clase PolicyIterationPlanner()
3.3.1 Resultados de la estimación del valor
3.3.2 La política final obtenida por iteración de políticas
1. Introducción
En el aprendizaje por refuerzo, según dependa del modelo (ambiental), se puede dividir en aprendizaje basado en modelos y aprendizaje sin modelos. De acuerdo con el punto de referencia de acción para la toma de decisiones, se puede dividir en aprendizaje basado en valores (basado en valores) y aprendizaje basado en políticas (basado en políticas).
En el aprendizaje basado en valores, las decisiones de acción se toman en función del valor de la función estado-valor (función estado-valor) o el valor de la función acción-valor. Elija siempre la acción correspondiente al estado con el valor más alto entre los siguientes estados que se pueden alcanzar desde el estado actual.
Los dos artículos anteriores introdujeron respectivamente la solución directa de la ecuación de Bellman para el cálculo de valores y la solución iterativa de aproximación de valores (iteración de valores):
Este artículo presenta además el principio del algoritmo de iteración de políticas y la implementación del aprendizaje basado en políticas.
2. Proceso de algoritmo
La iteración de políticas incluye la evaluación de políticas y la mejora de políticas.
La evaluación de políticas se refiere a la evaluación de la función de valor basada en la política actual, que en sí misma es (puede) ser resuelta de manera iterativa. Se supone que la valoración basada en políticas calcula el valor esperado del valor, que es ligeramente diferente de la valoración del valor en la iteración del valor. Sin embargo, dado que (como se muestra a continuación, la estrategia obtenida por la iteración de la estrategia en sí misma es una estrategia determinista, este valor esperado también degenera en el valor de la mejor acción bajo la estrategia actual). Cuando la evaluación de políticas se realiza en cada iteración, el valor inicial de la función de valor es la función de valor de la política anterior (política), lo que generalmente mejora la velocidad de convergencia de la evaluación de políticas, porque las funciones de valor de dos políticas adyacentes han cambiado poco.
La mejora de la política se refiere a la actualización de la política cuando la acción derivada de la política es inconsistente con la mejor acción basada en el valor.
El proceso de iteración de la estrategia dado por Sutton-book#4.3 es el siguiente:
Traducido al vernáculo de la siguiente manera:
Inicialización de valor y estrategia: el valor se inicializa en 0 y la probabilidad de todas las acciones en cada estado se especifica como una probabilidad igual (aunque se puede inicializar en cualquier valor, esta es la opción más razonable)
Iteración hasta la convergencia:
- Evaluación del valor de estado (valor esperado) basada en la política: sin embargo, de hecho, dado que la política en la iteración de políticas es una política determinista, el valor esperado aquí degenera en el valor de estado de la mejor acción.
- La política se actualiza en base al criterio de maximización del valor del estado. para cada estado
- La acción obtenida en base a la política actual (es decir, la acción con mayor probabilidad) action_by_policy
- Evalúe el valor Q(s,a) de cada acción para obtener la acción best_action_by_value con el valor de acción más alto
- Determine si los dos son consistentes (action_by_policy==best_action_by_value?)
- Si se cumple cada estado (action_by_policy==best_action_by_value), deja de iterar
- De lo contrario, actualice la política de manera codiciosa (¿es esto inevitable?). Es decir, la política[s][a] correspondiente a la mejor acción en cada estado s se establece en 1, y el resto se establece en 0
Más simplemente, se puede representar mediante el siguiente diagrama esquemático:
La relación entre la iteración de políticas y la iteración de valores [3]:
La iteración de la estrategia incluye la iteración del valor, la evaluación de la estrategia se basa en la estimación del valor y la estimación del valor se lleva a cabo en forma de iteración del valor. El algoritmo de iteración de valores es un algoritmo de iteración de políticas en el que el proceso de evaluación de políticas solo realiza una iteración.
3. Código y resultados de la simulación.
3.1 clase PolicyIterationPlanner()
estimacion_por_politica() se usa para estimar el valor esperado del estado bajo la política actual, que se usa para la selección de la mejor acción basada en el valor en el paso (2). estimar_por_política() es ligeramente diferente de la estimación de valor en ValueIterationPlanner, aquí está el valor esperado estimado (pero de hecho, debido a que es una estrategia determinista, en realidad degenera en el valor de la mejor acción bajo la estrategia actual), y el último es estimar directamente al máximo El valor de una buena acción.
plan() implementa el proceso descrito en el capítulo anterior. En el proceso iterativo, los resultados de la estimación del valor después de cada iteración se imprimen para facilitar la observación y comprensión de los resultados.
print_policy() se utiliza para imprimir la política final.
class PolicyIterationPlanner(Planner):
def __init__(self, env):
super().__init__(env)
self.policy = {}
def initialize(self):
super().initialize()
self.policy = {}
actions = self.env.actions
states = self.env.states
for s in states:
self.policy[s] = {}
for a in actions:
# Initialize policy.
# At first, each action is taken uniformly.
self.policy[s][a] = 1 / len(actions)
def estimate_by_policy(self, gamma, threshold):
V = {}
for s in self.env.states:
# Initialize each state's expected reward.
V[s] = 0
while True:
delta = 0
for s in V:
expected_rewards = []
for a in self.policy[s]:
action_prob = self.policy[s][a]
r = 0
for prob, next_state, reward in self.transitions_at(s, a):
r += action_prob * prob * \
(reward + gamma * V[next_state])
expected_rewards.append(r)
value = sum(expected_rewards)
delta = max(delta, abs(value - V[s]))
V[s] = value
if delta < threshold:
break
return V
def plan(self, gamma=0.9, threshold=0.0001):
self.initialize()
states = self.env.states
actions = self.env.actions
def take_max_action(action_value_dict):
return max(action_value_dict, key=action_value_dict.get)
while True:
update_stable = True
# Estimate expected rewards under current policy.
V = self.estimate_by_policy(gamma, threshold)
self.log.append(self.dict_to_grid(V))
for s in states:
# Get an action following to the current policy.
policy_action = take_max_action(self.policy[s])
# Compare with other actions.
action_rewards = {}
for a in actions:
r = 0
for prob, next_state, reward in self.transitions_at(s, a):
r += prob * (reward + gamma * V[next_state])
action_rewards[a] = r
best_action = take_max_action(action_rewards)
if policy_action != best_action:
update_stable = False
# Update policy (set best_action prob=1, otherwise=0 (greedy))
for a in self.policy[s]:
prob = 1 if a == best_action else 0
self.policy[s][a] = prob
# Turn dictionary to grid
self.V_grid = self.dict_to_grid(V)
self.iters = self.iters + 1
print('PolicyIteration: iters = {0}'.format(self.iters))
self.print_value_grid()
print('******************************')
if update_stable:
# If policy isn't updated, stop iteration
break
def print_policy(self):
print('PolicyIteration: policy = ')
actions = self.env.actions
states = self.env.states
for s in states:
print('\tstate = {}'.format(s))
for a in actions:
print('\t\taction = {0}, prob = {1}'.format(a,self.policy[s][a]))3.2 Código de prueba
El código de prueba es el siguiente (a modo de comparación, hay algunas modificaciones en valueIterPlanner y los resultados intermedios se imprimen para comparar):
if __name__ == "__main__":
# Create grid environment
grid = [
[0, 0, 0, 1],
[0, 9, 0, -1],
[0, 0, 0, 0]
]
env1 = Environment(grid)
valueIterPlanner = ValueIterationPlanner(env1)
valueIterPlanner.plan(0.9,0.001)
valueIterPlanner.print_value_grid()
env2 = Environment(grid)
policyIterPlanner = PolicyIterationPlanner(env2)
policyIterPlanner.plan(0.9,0.001)
policyIterPlanner.print_value_grid()
policyIterPlanner.print_policy() 3.3 Resultados de ejecución
3.3.1 Resultados de la estimación del valor
ValorIteración: iters = 1
-0.040 -0.040 0.792 0.000
-0.040 0.000 0.434 0.000
-0.040 -0.040 0.269 0.058
************************** **
......
ValorIteración: iters = 10
0.610 0.766 0.928 0.000
0.487 0.000 0.585 0.000
0.374 0.327 0.428 0.189
************************** * ****
Iteración de políticas: iters = 1
-0.270 -0.141
0.102 0.000 -0.345 0.000 -0.487 0.000
-0.399 -0.455 -0.537 -0.728
********************* * **********
......
Iteración de política: iters = 4
0,610 0,766 0,928 0,000
0,487 0,000 0,585 0,000
0,374 0,327 0,428 0,189
****************************
Los resultados de la estimación del valor final obtenidos por iteración de valor e iteración de estrategia son los mismos. Pero la iteración de políticas convergió en solo 4 iteraciones, mientras que la iteración de valor tomó 10 iteraciones.
3.3.2 La política final obtenida por iteración de políticas
El resultado final de la política de la iteración de la política es el siguiente:
PolicyIteration: política =
estado = <Estado: [0, 0]>
acción = Acción.ARRIBA, prob = 0
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
acción = Acción.DERECHA, prob = 1
estado = <Estado: [0, 1]>
acción = Acción.ARRIBA, prob = 0
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
acción = Acción.DERECHA, prob = 1
estado = <Estado: [0, 2]>
acción = Acción.ARRIBA, prob = 0
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
action = Action.RIGHT, prob = 1
state = <State: [0, 3]>
action = Action.UP, prob = 1
action = Action.DOWN, prob = 0
action = Action.LEFT, prob = 0
action = Action .DERECHA, prob = 0
estado = <Estado: [1, 0]>
acción = Acción.ARRIBA, prob = 1
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
acción = Acción.DERECHA, prob = 0
estado = <Estado: [1, 2]>
acción = Acción.ARRIBA, prob = 1
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
action = Action.RIGHT, prob = 0
state = <Estado: [1, 3]>
action = Action.UP, prob = 1
action = Action.DOWN, prob = 0
action = Action.LEFT, prob = 0
action = Action .DERECHA, prob = 0
estado = <Estado: [2, 0]>
acción = Acción.ARRIBA, prob = 1
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
acción = Acción.DERECHA, prob = 0
estado = <Estado: [2, 1]>
acción = Acción.ARRIBA, prob = 0
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 0
action = Action.RIGHT, prob = 1
state = <State: [2, 2]>
action = Action.UP, prob = 1
action = Action.DOWN, prob = 0
action = Action.LEFT, prob = 0
action = Action .DERECHA, prob = 0
estado = <Estado: [2, 3]>
acción = Acción.ARRIBA, prob = 0
acción = Acción.ABAJO, prob = 0
acción = Acción.IZQUIERDA, prob = 1
acción = Acción.DERECHA, probabilidad = 0
Este resultado se puede ilustrar de la siguiente manera ([4], ignore los resultados en [0,3] y [1,3] en los resultados anteriores):
【pensar】
¿El método de actualización de políticas en la iteración de políticas anterior solo se puede realizar de manera codiciosa? La estrategia se actualiza de forma codiciosa, y la estrategia final debe ser una estrategia determinista, es decir, en cada estado, la probabilidad de solo una de las mejores acciones es 1, y la probabilidad de otras acciones es 0.
Apuntes de Estudio Intensivo: Catálogo General de Apuntes de Estudio Intensivo
Vea el código completo: refuerzo-aprendizaje/value_eval en main chenxy3791/reinforcement-learning (github.com)
referencias:
【1】Sutton, et, al, Introducción al aprendizaje por refuerzo (2020)
[2] Takahiro Kubo, Aprendizaje práctico con Python para el aprendizaje por refuerzo
【4】Iteración de políticas: Introducción al aprendizaje por refuerzo (gibberblot.github.io)