Directorio de artículos
Prefacio
Esta publicación de blog simplemente usará Q-learning para implementar un ejemplo. Hay tesoros en el lado derecho del mundo. Siempre que el explorador obtenga el tesoro y pruebe la dulzura, recordará el método para obtener el tesoro en el futuro Este es el comportamiento que aprendió con el aprendizaje por refuerzo.
-o: T
T es la ubicación del tesoro, o es la ubicación del explorador
Q-learning es un método para registrar el valor del comportamiento (valor Q). Cada comportamiento en un estado determinado tendrá un valor Q (s, a) , lo que significa que el valor del comportamiento a en el estado s es Q (s, a). ) . S en el juego anterior es exploradores o lugar donde el tiempo en cada ubicación exploradores pueden hacer dos actos izquierda / derecha , esto es todos los exploradores factibles de una .
Si en una determinada ubicación s1, el explorador calcula los dos comportamientos que puede tener, a1 / a2 = izquierda / derecha , y el resultado del cálculo es Q (s1, a1)> Q (s1, a2) , entonces el explorador elegirá El comportamiento de la izquierda Esta es la regla simple de la selección del comportamiento de aprendizaje Q.
valor por defecto
Esta vez se requieren ajustes de módulo y parámetros:
import numpy as np
import pandas as pd
import time
N_STATES = 6 # 1维世界的宽度
ACTIONS = ['left', 'right'] # 探索者的可用动作
EPSILON = 0.9 # 贪婪度 greedy
ALPHA = 0.1 # 学习率
GAMMA = 0.9 # 奖励递减值
MAX_EPISODES = 13 # 最大回合数
FRESH_TIME = 0.3 # 移动间隔时间
Q mesa
Para el aprendizaje tabular de Q, debemos poner todos los valores de Q (valores de comportamiento) en q_table, y actualizar q_table también es actualizar su código de conducta. El índice de q_table son todos los estados correspondientes (posiciones del explorador), y las columnas son acciones correspondientes ( Comportamiento del explorador).
def build_q_table(n_states, actions):
table = pd.DataFrame(
np.zeros((n_states, len(actions))), # q_table 全 0 初始
columns=actions, # columns 对应的是行为名称
)
return table
# q_table:
"""
left right
0 0.0 0.0
1 0.0 0.0
2 0.0 0.0
3 0.0 0.0
4 0.0 0.0
5 0.0 0.0
"""
Definir acciones
Luego, defina cómo el explorador elige el comportamiento. Este es el concepto que introdujimos épsilon codicioso. Porque en la etapa inicial, el entorno de exploración aleatoria es a menudo mejor que el patrón de comportamiento fijo, por lo que esta es también la etapa de acumulación de experiencia. Esperamos que el El explorador no será tan codicioso (codicioso). Entonces, EPSILON es el valor utilizado para controlar el grado de codicia. EPSILON puede seguir mejorando con el tiempo de exploración (cada vez más codicioso), pero en este ejemplo, fijamos EPSILON = 0.9 , 90% El tiempo es para elegir la estrategia óptima, el 10% del tiempo para explorar.
# 在某个 state 地点, 选择行为
def choose_action(state, q_table):
state_actions = q_table.iloc[state, :] # 选出这个 state 的所有 action 值
if (np.random.uniform() > EPSILON) or (state_actions.all() == 0): # 非贪婪 or 或者这个 state 还没有探索过
action_name = np.random.choice(ACTIONS)
else:
action_name = state_actions.argmax() # 贪婪模式
return action_name
Retroalimentación ambiental S_, R
Después de que actuemos, el entorno también debería darnos una retroalimentación sobre nuestro comportamiento, retroalimentar el siguiente estado (S_) y la recompensa ® obtenida al realizar la acción (A) en el estado anterior (S). La regla definida aquí es que solo cuando o se mueve a T, el explorador obtendrá la única recompensa, el valor de recompensa R = 1, y no hay recompensa en otros casos.
def get_env_feedback(S, A):
# This is how agent will interact with the environment
if A == 'right': # move right
if S == N_STATES - 2: # terminate
S_ = 'terminal'
R = 1
else:
S_ = S + 1
R = 0
else: # move left
R = 0
if S == 0:
S_ = S # reach the wall
else:
S_ = S - 1
return S_, R
Actualización del entorno
El siguiente paso es actualizar el entorno, no lo mires más de cerca.
def update_env(S, episode, step_counter):
# This is how environment be updated
env_list = ['-']*(N_STATES-1) + ['T'] # '---------T' our environment
if S == 'terminal':
interaction = 'Episode %s: total_steps = %s' % (episode+1, step_counter)
print('\r{}'.format(interaction), end='')
time.sleep(2)
print('\r ', end='')
else:
env_list[S] = 'o'
interaction = ''.join(env_list)
print('\r{}'.format(interaction), end='')
time.sleep(FRESH_TIME)
Bucle principal de aprendizaje por refuerzo
El lugar más importante es aquí. Los métodos de RL que defina se reflejan todos aquí. En los siguientes tutoriales, explicaremos los diversos métodos en RL con más detalle. El siguiente contenido, puede verlo, el contenido de esta sección No Necesito estudiar cuidadosamente.
def rl():
q_table = build_q_table(N_STATES, ACTIONS) # 初始 q table
for episode in range(MAX_EPISODES): # 回合
step_counter = 0
S = 0 # 回合初始位置
is_terminated = False # 是否回合结束
update_env(S, episode, step_counter) # 环境更新
while not is_terminated:
A = choose_action(S, q_table) # 选行为
S_, R = get_env_feedback(S, A) # 实施行为并得到环境的反馈
q_predict = q_table.loc[S, A] # 估算的(状态-行为)值
if S_ != 'terminal':
q_target = R + GAMMA * q_table.iloc[S_, :].max() # 实际的(状态-行为)值 (回合没结束)
else:
q_target = R # 实际的(状态-行为)值 (回合结束)
is_terminated = True # terminate this episode
q_table.loc[S, A] += ALPHA * (q_target - q_predict) # q_table 更新
S = S_ # 探索者移动到下一个 state
update_env(S, episode, step_counter+1) # 环境更新
step_counter += 1
return q_table
Después de escribir todas las evaluaciones y actualizar las pautas, podemos empezar a entrenar, lanzar al explorador al entorno y dejar que juegue solo.
if __name__ == "__main__":
q_table = rl()
print('\r\nQ-table:\n')
print(q_table)
referencia
https://mofanpy.com/tutorials/machine-learning/reinforcement-learning/general-rl/