Q-Learning para juegos

Introducion

Para empezar vamos a definir algunos elementos de un juego:

• Observación: es el estado actual de la partida. Donde se encuentran los jugadores/piezas, a que velocidad se mueve una bola,...
• Agente: Quien decide que acción va a tomar

Nuestro algoritmo de Q-learning decidirá creará un agente que nos decida que acción tomar para cada observación de la partida.

Base del algoritmo

El algoritmo aprenderá por refuerzo positivo o negativo, es decir, dada una acción para una observacion le daremos una recompensa positiva o negativa. Este no puede ser el único requisito, pues el camino a recibir una recompensa debe ser recompensado también. Por lo que:

• llamamos $Q(s_t,a_t)$ a la calidad de la accion $a_t$ para la observación $s_t$ para el tiempo $t$
• llamamos $r(s_t)$ a la recompensa recibida en la observación $s_t$
• llamamos $\alpha$ al ratio de aprenzaje, es decir, cuanto de rápido se va a propagar la recompensa
• llamamos $\gamma$ al factor de descuento

$\max_a Q(s_{t+1},a)$ es el máximo Q de las posibles nuevas observaciones

matematicas por debajo

El algoritmo de q-learning se realiza en un (modelo de Markov)[https://es.wikipedia.org/wiki/Cadena_de_M%C3%A1rkov], es decir, es un proceso donde la probabilidad de que ocurra un evento depende solamente del proceso anterior.

Implementación

Algoritmo realizado con chatGPT!

import numpy as np

# Creamos la clase para el agente
class Agent:
  def __init__(self, state_size, action_size):
    self.state_size = state_size
    self.action_size = action_size
    self.q_table = np.zeros((state_size, action_size))

  # Seleccionamos una acción
  def choose_action(self, state, epsilon):
    if np.random.random() < epsilon:
      return np.random.randint(self.action_size)
    else:
      return np.argmax(self.q_table[state])

# Actualizamos la tabla Q
def update_q_table(agent, state, action, reward, next_state):
  alpha = 0.1
  gamma = 0.9
  new_q = reward + gamma * np.max(agent.q_table[next_state])
  old_q = agent.q_table[state, action]
  agent.q_table[state, action] = (1 - alpha) * old_q + alpha * new_q