El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Aprendizaje por Refuerzo

Siguiente ►
►

El aprendizaje por refuerzo (RL, por sus siglas en inglés) es una rama del aprendizaje automático que se centra en cómo los agentes deben tomar acciones en un entorno para maximizar alguna noción de recompensa acumulada. A diferencia de otros paradigmas de aprendizaje, el RL se basa en la interacción continua con el entorno y la retroalimentación en forma de recompensas o castigos.

Conceptos Clave

  1. Agente: La entidad que toma decisiones y aprende de las interacciones con el entorno.
  2. Entorno: Todo lo que rodea al agente y con lo que interactúa.
  3. Estado (s): Una representación de la situación actual del entorno.
  4. Acción (a): Una decisión tomada por el agente que afecta el estado del entorno.
  5. Recompensa (r): Retroalimentación recibida por el agente después de tomar una acción.
  6. Política (π): Una estrategia que define las acciones que debe tomar el agente en cada estado.
  7. Función de valor (V): Una estimación del valor esperado de los estados, es decir, la recompensa total esperada a largo plazo.
  8. Función Q (Q(s, a)): Una estimación del valor esperado de tomar una acción en un estado particular.

Ejemplo Práctico: El Problema del Camino Óptimo

Imaginemos un agente que debe encontrar el camino óptimo en un laberinto. El agente recibe una recompensa positiva al llegar a la salida y recompensas negativas al chocar con paredes.

Pseudocódigo de Q-Learning

Q-Learning es uno de los algoritmos más populares en RL. Aquí hay un pseudocódigo básico:

# Inicialización
Q = {}  # Tabla Q vacía
for each state s and action a:
    Q[s, a] = 0  # Inicializar Q(s, a) arbitrariamente

# Parámetros
alpha = 0.1  # Tasa de aprendizaje
gamma = 0.9  # Factor de descuento
epsilon = 0.1  # Parámetro de exploración-explotación

# Episodios de entrenamiento
for episode in range(num_episodes):
    state = initial_state  # Estado inicial
    while state is not terminal:
        # Selección de acción (ε-greedy)
        if random() < epsilon:
            action = random_action()
        else:
            action = argmax(Q[state, a] for a in actions(state))
        
        # Realizar acción y observar resultado
        next_state, reward = take_action(state, action)
        
        # Actualización de Q
        best_next_action = argmax(Q[next_state, a] for a in actions(next_state))
        Q[state, action] = Q[state, action] + alpha * (reward + gamma * Q[next_state, best_next_action] - Q[state, action])
        
        state = next_state

Explicación del Código

  1. Inicialización: Se crea una tabla Q vacía y se inicializan los valores de Q(s, a) a cero.
  2. Parámetros: Se definen los parámetros de tasa de aprendizaje (alpha), factor de descuento (gamma) y el parámetro de exploración-explotación (epsilon).
  3. Episodios de Entrenamiento: Se ejecutan múltiples episodios de entrenamiento donde el agente interactúa con el entorno.
  4. Selección de Acción: Se utiliza una política ε-greedy para balancear la exploración y explotación.
  5. Actualización de Q: Se actualiza la tabla Q utilizando la fórmula de Q-Learning.

Ejercicio Práctico

Ejercicio 1: Implementar Q-Learning en un Laberinto

Objetivo: Implementar el algoritmo Q-Learning para que un agente encuentre la salida de un laberinto.

Instrucciones:

  1. Define un entorno de laberinto.
  2. Implementa el algoritmo Q-Learning.
  3. Entrena al agente y observa su comportamiento.
import numpy as np
import random

# Definición del entorno
class Laberinto:
    def __init__(self, grid):
        self.grid = grid
        self.start = (0, 0)
        self.end = (len(grid) - 1, len(grid[0]) - 1)
    
    def reset(self):
        self.position = self.start
        return self.position
    
    def step(self, action):
        x, y = self.position
        if action == 'up':
            x -= 1
        elif action == 'down':
            x += 1
        elif action == 'left':
            y -= 1
        elif action == 'right':
            y += 1
        
        if x < 0 or x >= len(self.grid) or y < 0 or y >= len(self.grid[0]) or self.grid[x][y] == 1:
            return self.position, -1, False  # Recompensa negativa por chocar con una pared
        
        self.position = (x, y)
        if self.position == self.end:
            return self.position, 10, True  # Recompensa positiva por llegar a la salida
        
        return self.position, -0.1, False  # Recompensa negativa por cada paso

# Parámetros
alpha = 0.1
gamma = 0.9
epsilon = 0.1
num_episodes = 1000

# Inicialización
laberinto = Laberinto([
    [0, 0, 0, 0],
    [1, 1, 0, 1],
    [0, 0, 0, 0],
    [0, 1, 1, 0],
    [0, 0, 0, 0]
])
Q = {}
actions = ['up', 'down', 'left', 'right']

for x in range(len(laberinto.grid)):
    for y in range(len(laberinto.grid[0])):
        for action in actions:
            Q[((x, y), action)] = 0

# Entrenamiento
for episode in range(num_episodes):
    state = laberinto.reset()
    done = False
    while not done:
        if random.random() < epsilon:
            action = random.choice(actions)
        else:
            action = max(actions, key=lambda a: Q[(state, a)])
        
        next_state, reward, done = laberinto.step(action)
        best_next_action = max(actions, key=lambda a: Q[(next_state, a)])
        Q[(state, action)] = Q[(state, action)] + alpha * (reward + gamma * Q[(next_state, best_next_action)] - Q[(state, action)])
        state = next_state

# Prueba del agente entrenado
state = laberinto.reset()
done = False
path = [state]
while not done:
    action = max(actions, key=lambda a: Q[(state, a)])
    state, _, done = laberinto.step(action)
    path.append(state)

print("Camino encontrado por el agente:", path)

Solución del Ejercicio

El código anterior implementa el algoritmo Q-Learning en un entorno de laberinto. El agente aprende a encontrar la salida del laberinto mediante la interacción continua con el entorno y la actualización de la tabla Q.

Conclusión

En esta sección, hemos aprendido los conceptos básicos del aprendizaje por refuerzo y cómo implementar el algoritmo Q-Learning para resolver problemas de navegación en un entorno de laberinto. El aprendizaje por refuerzo es una herramienta poderosa para desarrollar comportamientos inteligentes en los personajes de los videojuegos, permitiéndoles aprender y adaptarse a través de la experiencia.

En el siguiente módulo, exploraremos cómo integrar estos algoritmos de IA en motores de juego y optimizar su rendimiento.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados