Q Learning en Python: qué es, definiciones [ejemplos de codificación]

El aprendizaje por refuerzo es cuando un agente de aprendizaje aprende a comportarse de manera óptima de acuerdo con su entorno a través de interacciones constantes. El agente pasa por diversas situaciones, que también se conocen como estados. Como habrás adivinado, el aprendizaje por refuerzo tiene muchas aplicaciones en nuestro mundo. Obtenga más información si está interesado en obtener más información sobre los algoritmos de ciencia de datos.

Además, tiene muchos algoritmos, entre los más populares está Q learning . En este artículo, discutiremos qué es este algoritmo y cómo funciona.

Entonces, sin más preámbulos, comencemos.

¿Qué es Q Learning?

El aprendizaje Q es un algoritmo de aprendizaje por refuerzo y se centra en encontrar el mejor curso de acción para una situación particular. Está fuera de la política porque las acciones de las que aprende la función de aprendizaje Q están fuera de la política existente, por lo que no requiere una. Se enfoca en aprender una política que aumente su recompensa total. Es una forma simple de aprendizaje por refuerzo que utiliza valores de acción (o valores Q) para mejorar el comportamiento del agente de aprendizaje.

El aprendizaje Q es uno de los algoritmos más populares en el aprendizaje por refuerzo, ya que es fácil de entender e implementar. La 'Q' en el aprendizaje Q representa calidad. Como mencionamos anteriormente, Q learning se enfoca en encontrar la mejor acción para una situación particular. Y la calidad muestra cuán útil es una acción específica y qué recompensa puede ayudarlo a alcanzar.

Definiciones importantes

Antes de comenzar a discutir cómo funciona, primero debemos echar un vistazo a algunos conceptos esenciales del aprendizaje q. Empecemos.

Valores Q

Los valores Q también se conocen como valores de acción. Están representados por Q(S, A), y le dan una estimación de qué tan buena es la acción A para tomar en el estado S. El modelo calculará esta estimación iterativamente usando la regla de actualización de diferencia temporal que hemos discutido más adelante. en esta sección.

Episodios y recompensas

Un agente comienza desde un estado inicial, pasa por varias transiciones y luego pasa de su estado actual al siguiente de acuerdo con sus acciones y su entorno. Cada vez que el agente actúa, obtiene alguna recompensa. Y cuando no hay transiciones posibles, es la finalización del episodio.

Actualización TD (diferencia temporal)

Aquí está la regla de actualización de TD o diferencia temporal:

Q(S,A) Q(S,A) + (R + Q(S',A')-Q(S,A))

Aquí, S representa el estado actual del agente, mientras que S' representa el siguiente estado. A representa la acción actual, A' representa la siguiente mejor acción según la estimación del valor Q, R muestra la recompensa actual según la acción actual, representa el factor de descuento y muestra la longitud del paso.

Lea también: Requisito previo para la ciencia de datos. ¿Cómo cambia con el tiempo?

Ejemplo de Q Learning Python

La mejor manera de entender Q aprendiendo Python es ver un ejemplo. En este ejemplo, usamos el entorno de gimnasio de OpenAI y entrenamos nuestro modelo con él. En primer lugar, deberá instalar el entorno. Puedes hacerlo con el siguiente comando:

pip instalar gimnasio

Ahora, importaremos las bibliotecas que necesitaremos para este ejemplo:

importar gimnasio

importar itertools

importar matplotlib

importar matplotlib.estilo

importar numpy como np

importar pandas como pd

sistema de importación

desde colecciones importar predeterminadodict

de windy_gridworld importar WindyGridworldEnv

importación de trazado

matplotlib.style.use('ggplot')

Sin las bibliotecas necesarias, no podría realizar estas operaciones correctamente. Después de haber importado las bibliotecas, crearemos el entorno:

env = WindyGridworldEnv()

Ahora crearemos la política -greedy:

def createEpsilonGreedyPolicy(Q, epsilon, num_actions):

“””

Crea una política ávida de épsilon basada

en una función Q dada y épsilon.

Devuelve una función que toma el estado

como entrada y devuelve las probabilidades

para cada acción en forma de matriz numpy

de la longitud del espacio de acción (conjunto de posibles respuestas).

“””

def políticaFunción(estado):

Probabilidades_de_acción = np.ones(num_acciones,

dtype = float) * epsilon / num_actions

mejor_acción = np.argmax(Q[estado])

Probabilidades_de_acción[mejor_acción] += (1.0 – épsilon)

volver Action_probabilidades

política de devoluciónFunción

Aquí está el código para construir un modelo q-learning:

def qLearning(env, num_episodes, descuento_factor = 1.0,

alfa = 0,6, épsilon = 0,1):

“””

Algoritmo Q-Learning: Control de TD fuera de política.

Encuentra la política codiciosa óptima mientras mejora

siguiendo una política de avaricia épsilon”””

# Función de valor de acción

# Un diccionario anidado que mapea

# estado -> (acción -> valor-acción).

Q = predeterminadodict(lambda: np.zeros(env.action_space.n))

# Realiza un seguimiento de las estadísticas útiles

stats = plotting.EpisodeStats(

episodios_duraciones = np.zeros(núm_episodios),

episodio_recompensas = np.zeros(núm_episodios))

# Crear una función de política codiciosa epsilon

# apropiadamente para el espacio de acción ambiental

política = createEpsilonGreedyPolicy(Q, epsilon, env.action_space.n)

# Por cada episodio

para ith_episode en rango (num_episodes):

# Restablecer el entorno y elegir la primera acción

estado = env.reset()

para t en itertools.count():

# obtener probabilidades de todas las acciones del estado actual

probabilidad_de_acción = política(estado)

# elige la acción según

# la distribución de probabilidad

acción = np.random.choice(np.arange(

len(acción_probabilidades)),

p = probabilidades_de_acción)

# tomar medidas y obtener una recompensa, pasar al siguiente estado

next_state, recompensa, hecho, _ = env.step (acción)

# Actualizar estadísticas

stats.episode_rewards[i_episode] += recompensa

stats.episode_lengths[i_episode] = t

# Actualización de TD

mejor_siguiente_acción = np.argmax(Q[siguiente_estado])

td_target = recompensa + descuento_factor * Q[next_state][best_next_action]

td_delta = td_objetivo – Q[estado][acción]

Q[estado][acción] += alfa * td_delta

# hecho es Verdadero si el episodio terminó

si se hace:

descanso

estado = siguiente_estado

devolver Q, estadísticas

Entrenemos el modelo ahora:

Q, estadísticas = qLearning(env, 1000)

Después de haber creado y entrenado el modelo, podemos trazar las estadísticas esenciales del mismo:

plotting.plot_episode_stats(estadísticas)

Utilice este código para ejecutar el modelo y trazar el gráfico. ¿Qué tipo de resultados ves? Comparta sus resultados con nosotros, y si tiene alguna confusión o duda, háganoslo saber.

Lea también: Algoritmos de aprendizaje automático para ciencia de datos

Aprenda cursos de ciencia de datos de las mejores universidades del mundo. Obtenga programas Executive PG, programas de certificados avanzados o programas de maestría para acelerar su carrera.

Pensamientos finales

Cuando traces el gráfico, verás que la recompensa por episodio aumenta progresivamente con el tiempo. Y después de ciertos episodios, la trama también refleja que nivela el límite alto de recompensa por episodio. ¿Qué indica esto?

Significa que su modelo ha aprendido a aumentar la recompensa total que puede ganar en un episodio asegurándose de que se comporta de manera óptima. También debe haber visto por qué q aprender Python ve aplicaciones en tantas industrias y áreas.