En este tutorial, exploramos cómo las estrategias de exploración dan forma a la toma de decisiones inteligente a través de la resolución de problemas basada en agentes. Creamos y entrenamos a tres agentes, Q-Learning con exploración épsilon, Upper Confidence Bound (UCB) y Monte Carlo Tree Search (MCTS), para navegar en un mundo en red y alcanzar una meta de manera eficiente mientras evitamos obstáculos. Además, experimentamos con diferentes formas de equilibrar la exploración y la explotación, visualizamos curvas de aprendizaje y comparamos cómo cada agente se adapta y se desempeña bajo incertidumbre. Consulta los CÓDIGOS COMPLETOS aquí.
Comenzamos creando un entorno mundial en red que desafía a nuestro agente a alcanzar una meta evitando obstáculos. Diseñamos su estructura, definimos reglas de movimiento y garantizamos límites de navegación realistas para simular un espacio interactivo de resolución de problemas. Esto forma la base sobre la que nuestros agentes de exploración operarán y aprenderán. Consulta los CÓDIGOS COMPLETOS aquí.
Implementamos el agente Q-Learning que aprende a través de la experiencia, guiados por una política épsilon-codiciosa. Observamos cómo explora acciones aleatorias desde el principio y se centra gradualmente en los caminos más gratificantes. A través de actualizaciones iterativas, aprende a equilibrar la exploración y la explotación de forma eficaz.
para acción en valid_actions: q = self.q_values[state][action]
contar = self.action_counts[state][action]
si cuenta == 0: acción de retorno exploración_bonus = self.c * math.sqrt(math.log(self.total_counts[state]) / recuento) ucb_values.append((acción, q + bonificación_exploración)) return max(ucb_values, clave=lambda x: x[1])[0]
def actualización(self, estado, acción, recompensa, next_state, valid_next_actions): self.action_counts[state][action] += 1 recuento = self.action_counts[state][action]
current_q = self.q_valores[state][action]
si valid_next_actions: max_next_q = max([self.q_values[next_state][a] para a en valid_next_actions]) más: max_next_q = 0 objetivo = recompensa + self.gamma * max_next_q self.q_values[state][action] += (objetivo – current_q) / recuento
Desarrollamos el agente UCB que utiliza límites de confianza para guiar sus decisiones de exploración. Observamos cómo intenta estratégicamente acciones menos visitadas y al mismo tiempo prioriza aquellas que generan mayores recompensas. Este enfoque nos ayuda a comprender una estrategia de exploración más fundamentada matemáticamente. Consulta los CÓDIGOS COMPLETOS aquí.
c * math.sqrt(2 * math.log(self.visits) / child.visits))
for action, child in self.children.items()]
devolver max(opciones, clave=lambda x: x[1]) clase MCTSAgent: def __init__(self, env, n_simulators=50): self.env = env self.n_simulators = n_simulators def search(self, state): root = MCTSNode(state) for _ in range(self.n_simulators): nodo = raíz sim_env = GridWorld(size=self.env.size) sim_env.grid = self.env.grid.copy() sim_env.agent_pos = estado mientras node.is_fully_expanded(sim_env.get_valid_actions(node.state)) y node.children: acción, _ = node.best_child() nodo = node.children[action]
sim_env.agent_pos = node.state valid_actions = sim_env.get_valid_actions(node.state) si valid_actions y no node.is_fully_expanded(valid_actions): no probado = [a for a in valid_actions if a not in node.children]
acción = random.choice(no probado) next_state, _, _ = sim_env.step(action) child = MCTSNode(next_state, parent=nodo) node.children[action] = nodo hijo = hijo total_reward = 0 profundidad = 0 mientras profundidad < 20: válido = sim_env.get_valid_actions(sim_env.agent_pos) si no es válido: romper acción = random.choice(valid) _, recompensa, hecho = sim_env.step(action) total_reward += profundidad de recompensa += 1 si está hecho: romper mientras nodo: nodo.visitas += 1 nodo.valor += nodo_recompensa total = nodo.parent si root.children: devuelve max(root.children.items(), clave=lambda x: x[1].visitas)[0] devolver random.choice(self.env.get_valid_actions(estado))
Construimos el agente Monte Carlo Tree Search (MCTS) para simular y planificar múltiples resultados potenciales futuros. Vemos cómo construye un árbol de búsqueda, expande ramas prometedoras y propaga hacia atrás los resultados para refinar las decisiones. Esto permite al agente planificar inteligentemente antes de actuar. Consulta los CÓDIGOS COMPLETOS aquí.
para episodio en rango(episodios): estado = env.reset() recompensa_total = 0 para paso en rango(max_steps): valid_actions = env.get_valid_actions(estado) if agente_tipo == “mcts”: acción = agente.search(estado) else: acción = agente.get_action(estado, valid_actions) siguiente_estado, recompensa, hecho = env.step(acción) recompensa_total += recompensa si tipo_agente!= “mcts”: valid_next = env.get_valid_actions(next_state) agente.update(estado, acción, recompensa, siguiente_estado, valid_next) estado = siguiente_estado si está hecho: romper recompensas_historia.append(total_reward) si hasattr(agente, ‘decay_epsilon’): agente.decay_epsilon() si (episodio + 1) % 100 == 0: avg_reward = np.mean(rewards_history[-100:]) print(f”Episodio {episodio+1}/{episodios}, Recompensa promedio: {avg_reward:.2f}”) return recompensas_history if __name__ == “__main__”: print(“=” * 70) print(“Resolución de problemas a través del tutorial de agentes de exploración”) print(“=” * 70) env = GridWorld(size=8, n_obstacles=10) agentes_config = { ‘Q-Learning (ε-greedy)’: (QLearningAgent(), ‘estándar’), ‘UCB Agent’: (UCBAgent(), ‘estándar’), ‘MCTS Agent’: (MCTSAgent(env, n_simulations=30), ‘mcts’) } resultados = {} para nombre, (agente, agente_tipo) en agentes_config.items(): print(f”\nTraining {nombre}…”) recompensas = train_agent(agente, GridWorld(tamaño=8, n_obstacles=10), episodios=300, agente_tipo=agente_tipo) resultados[name] = recompensas plt.figure(figsize=(12, 5)) plt.subplot(1, 2, 1) por nombre, recompensas en results.items(): suavizado = np.convolve(rewards, np.ones(20)/20, mode=”valid”) plt.plot(smoothed, label=name, linewidth=2) plt.xlabel(‘Episodio’) plt.ylabel(‘Recompensa (suavizada)’) plt.title(‘Comparación de rendimiento del agente’) plt.legend() plt.grid(alpha=0.3) plt.subplot(1, 2, 2) para el nombre, recompensas en results.items(): avg_last_100 = np.mean(rewards)[-100:]) plt.bar(nombre, avg_last_100, alpha=0.7) plt.ylabel(‘Recompensa promedio (Últimos 100 episodios)’) plt.title(‘Actuación final’) plt.xticks(rotation=15, ha=”right”) plt.grid(axis=”y”, alpha=0.3) plt.tight_layout() plt.show() print(“=” * 70) print(“¡Tutorial completo!”) print(“Conceptos clave demostrados:”) print(“1. Exploración Epsilon-Greedy”) print(“2. Estrategia UCB”) print(“3. Planificación basada en MCTS”) print(“=” * 70)
Capacitamos a los tres agentes en nuestro mundo grid y visualizamos su progreso y desempeño en el aprendizaje. Analizamos cómo cada estrategia, Q-Learning, UCB y MCTS, se adapta al entorno a lo largo del tiempo. Finalmente, comparamos resultados y obtenemos información sobre qué enfoque de exploración conduce a una resolución de problemas más rápida y confiable.
En conclusión, implementamos y comparamos con éxito tres agentes impulsados por la exploración, cada uno de los cuales demuestra una estrategia única para resolver el mismo desafío de navegación. Observamos cómo épsilon-greedy permite el aprendizaje gradual a través de la aleatoriedad, UCB equilibra la confianza con la curiosidad y MCTS aprovecha implementaciones simuladas para la previsión y la planificación. Este ejercicio nos ayuda a apreciar cómo los diferentes mecanismos de exploración influyen en la convergencia, la adaptabilidad y la eficiencia en el aprendizaje por refuerzo.
Consulta los CÓDIGOS COMPLETOS aquí. No dude en consultar nuestra página de GitHub para tutoriales, códigos y cuadernos. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutivo de Marktechpost Media Inc.. Como empresario e ingeniero visionario, Asif está comprometido a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, Marktechpost, que se destaca por su cobertura en profundidad del aprendizaje automático y las noticias sobre aprendizaje profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el público.
🙌 Siga MARKTECHPOST: agréguenos como fuente preferida en Google.