Cómo construir un agente de metarazonamiento adaptativo que elija dinámicamente entre estrategias de pensamiento rápidas, profundas y basadas en herramientas

Comenzamos este tutorial construyendo un agente de metarazonamiento que decide cómo pensar antes de pensar. En lugar de aplicar el mismo proceso de razonamiento para cada consulta, diseñamos un sistema que evalúa la complejidad, elige entre heurísticas rápidas, razonamiento en cadena de pensamiento profundo o computación basada en herramientas, y luego adapta su comportamiento en tiempo real. Al examinar cada componente, entendemos cómo un agente inteligente puede regular su esfuerzo cognitivo, equilibrar la velocidad y la precisión, y seguir una estrategia que se alinee con la naturaleza del problema. Al hacer esto, experimentamos el cambio de respuestas reactivas a razonamiento estratégico. Consulte el CUADERNO DE CÓDIGO COMPLETO.

importar re importar tiempo importar aleatorio desde escribir importar Dict, Lista, Tupla, Literal desde clases de datos importar clase de datos, campo @dataclass clase Análisis de consulta: consulta: complejidad de cadena: Literal[“simple”, “medium”, “complex”]
estrategia: Literal[“fast”, “cot”, “tool”]
confianza: razonamiento flotante: str tiempo de ejecución: flotador = 0.0 éxito: bool = True clase MetaReasoningController: def __init__(self): self.query_history: Lista[QueryAnalysis] = []
self.patterns = { ‘matemáticas’: r'(\d+\s*[\+\-\*\/]\s*\d+)|calcular|calcular|suma|producto’, ‘buscar’: r’actual|últimas|noticias|hoy|quién es|qué es.*ahora’, ‘creativo’: r’escribir|poema|historia|broma|imagina’, ‘lógico’: r’si.*entonces|porque|por lo tanto|probar|explicar por qué’, ‘hecho_simple’: r’^(qué|quién|cuándo|dónde) (es|son|era|eran)’, } def analizar_query(self, consulta: str) -> QueryAnalysis: query_lower = query.lower() has_math = bool(re.search(self.patterns[‘math’]consulta_inferior)) necesidades_búsqueda = bool(re.search(self.patterns[‘search’]query_lower)) is_creative = bool(re.search(self.patterns[‘creative’]query_lower)) is_logic = bool(re.search(self.patterns[‘logical’]query_lower)) is_simple = bool(re.search(self.patterns[‘simple_fact’]query_lower)) word_count = len(query.split()) has_multiple_parts=”?” en consulta[:-1] o ‘;’ en la consulta si has_math: complejidad = estrategia “mediana” = razonamiento “herramienta” = “Matemáticas detectadas – uso de la herramienta calculadora para mayor precisión” confianza = 0,9 elif need_search: complejidad = estrategia “mediana” = razonamiento “herramienta” = “Información actual/dinámica – necesita herramienta de búsqueda” confianza = 0,85 elif is_simple y word_count < 10: complejidad = estrategia "simple" = razonamiento "rápido" = "Consulta fáctica simple - rápida recuperación suficiente" confianza = 0,95 elif is_logic o has_multiple_parts o word_count > 30: complejidad = estrategia “compleja” = razonamiento “cot” = “Se requiere razonamiento complejo – usando cadena de pensamiento” confianza = 0,8 elif is_creative: complejidad = estrategia “media” = razonamiento “cot” = “Tarea creativa – cadena de pensamiento para la generación de ideas” confianza = 0,75 else: complejidad = estrategia “media” = razonamiento “cot” = “complejidad poco clara – por defecto a cadena de pensamiento” confianza = 0,6 return QueryAnalysis(consulta, complejidad, estrategia, confianza, razonamiento)

Configuramos las estructuras centrales que permiten a nuestro agente analizar las consultas entrantes. Definimos cómo clasificamos la complejidad, detectamos patrones y decidimos la estrategia de razonamiento. A medida que construimos esta base, creamos el cerebro que determina cómo pensamos antes de responder. Consulte el CUADERNO DE CÓDIGO COMPLETO.

class FastHeuristicEngine: def __init__(self): self.knowledge_base = { ‘capital de francia’: ‘París’, ‘capital de españa’: ‘Madrid’, ‘velocidad de la luz’: ‘299,792,458 metros por segundo’, ‘punto de ebullición del agua’: ‘100°C o 212°F al nivel del mar’, } def respuesta(self, query: str) -> str: q = query.lower() para k, v en self.knowledge_base.items(): si k en q: devuelve f”Respuesta: {v}” si ‘hola’ en q o ‘hola’ en q: devuelve “¡Hola! ¿En qué puedo ayudarte?” devolver “Heurística rápida: no se encontró ninguna coincidencia directa”. clase ChainOfThoughtEngine: def respuesta (self, consulta: str) -> str: s = []
s.append(“Paso 1: Comprender la pregunta”) s.append(f” → La consulta pregunta sobre: ​​{consulta[:50]}…”) s.append(“\nPaso 2: Analizar el problema”) if ‘por qué’ en query.lower(): s.append(” → Esta es una pregunta causal que requiere explicación”) s.append(” → Necesita identificar causas y efectos”) elif ‘cómo’ en query.lower(): s.append(” → Esta es una pregunta de procedimiento”) s.append(” → Necesita delinear pasos o mecanismos”) else: s.append(” → Analizar conceptos y relaciones clave”) s.append(“\nPaso 3: Sintetizar la respuesta”) s.append(” → Combinar conocimientos de los pasos de razonamiento”) s.append(“\nPaso 4: Respuesta final”) s.append(” → [Detailed response based on reasoning chain]”) return “\n”.join(s) clase ToolExecutor: def calcular(self, expresión: str) -> float: m = re.search(r'(\d+\.?\d*)\s*([\+\-\*\/])\s*(\d+\.?\d*)’, expresión) if m: a, op, b = m.groups() a, b = float(a), float(b) ops = { ‘+’: lambda x, y: x + y, ‘-‘: lambda x, y: x – y, ‘*’: lambda x, y: x * y, ‘/’: lambda x, y: x / y if y != 0 else float(‘inf’), } operaciones de retorno[op](a, b) devolver Ninguno def búsqueda (self, consulta: cadena) -> cadena: devolver f”[Simulated search results for: {query}]” def ejecutar(self, consulta: str, tipo_herramienta: str) -> str: if tipo_herramienta == “calculadora”: r = self.calculate(consulta) si r no es Ninguno: devuelve f”Resultado de la calculadora: {r}” devuelve “No se pudo analizar la expresión matemática” elif tipo_herramienta == “búsqueda”: devuelve self.search(consulta) devuelve “Ejecución de herramienta completada”

Desarrollamos los motores que realmente realizan el pensamiento. Diseñamos un módulo heurístico rápido para búsquedas simples, un motor de cadena de pensamiento para un razonamiento más profundo y funciones de herramientas para cálculo o búsqueda. A medida que implementamos estos componentes, preparamos al agente para cambiar con flexibilidad entre diferentes modos de inteligencia. Consulte el CUADERNO DE CÓDIGO COMPLETO.

clase MetaReasoningAgent: def __init__(self): self.controller = MetaReasoningController() self.fast_engine = FastHeuristicEngine() self.cot_engine = ChainOfThoughtEngine() self.tool_executor = ToolExecutor() self.stats = { ‘fast’: {‘count’: 0, ‘total_time’: 0}, ‘cot’: {‘count’: 0, ‘tiempo_total’: 0}, ‘herramienta’: {‘count’: 0, ‘tiempo_total’: 0}, } def proceso_query(self, query: str, detallado: bool = True) -> str: if detallado: print(“\n” + “=”*60) print(f”QUERY: {query}”) print(“=”*60) t0 = time.time() análisis = self.controller.analyze_query(consulta) si es detallado: print(f”\n🧠 META-REASONING:”) print(f” Complejidad: {analysis.complexity}”) print(f” Estrategia: {analysis.strategy.upper()}”) print(f” Confianza: {analysis.confidence:.2%}”) print(f” Razonamiento: {analysis.reasoning}”) print(f”\n⚡ EJECUTANDO {análisis.estrategia.upper()} ESTRATEGIA…\n”) if análisis.estrategia == “rápido”: resp = self.fast_engine.answer(consulta) elif análisis.estrategia == “cot”: resp = self.cot_engine.answer(consulta) elif análisis.estrategia == “herramienta”: if re.search(self.controller.patterns[‘math’]query.lower()): resp = self.tool_executor.execute(consulta, “calculadora”) else: resp = self.tool_executor.execute(consulta, “buscar”) dt = time.time() – t0 análisis.execution_time = dt self.stats[analysis.strategy][‘count’] += 1 auto.estadísticas[analysis.strategy][‘total_time’] += dt self.controller.query_history.append(analysis) if detallado: print(resp) print(f”\n⏱️ Tiempo de ejecución: {dt:.4f}s”) return resp def show_stats(self): print(“\n” + “=”*60) print(“ESTADÍSTICAS DE RENDIMIENTO DEL AGENTE”) print(“=”*60) for s, d in self.stats.items(): si d[‘count’] > 0: promedio = d[‘total_time’] / d[‘count’]
print(f”\n{s.upper()} Estrategia:”) print(f” Consultas procesadas: {d[‘count’]}”) print(f” Tiempo promedio: {avg:.4f}s”) print(“\n” + “=”*60)

Reunimos todos los componentes en un agente unificado. Orquestamos el flujo desde el metarazonamiento hasta la ejecución, realizamos un seguimiento del desempeño y observamos cómo se comporta cada estrategia. A medida que ejecutamos este sistema, vemos a nuestro agente decidir, razonar y adaptarse en tiempo real. Consulte el CUADERNO DE CÓDIGO COMPLETO.

def run_tutorial(): print(“”” TUTORIAL DEL AGENTE DE META RAZONAMIENTO “¿Cuándo debo pensar detenidamente o responder rápido?” Este agente demuestra: 1. Razonamiento rápido versus profundo versus razonamiento basado en herramientas 2. Elección de una estrategia cognitiva 3. Inteligencia adaptativa “””) agente = MetaReasoningAgent() test_queries = [
“What is the capital of France?”,
“Calculate 156 * 23”,
“Why do birds migrate south for winter?”,
“What is the latest news today?”,
“Hello!”,
“If all humans need oxygen and John is human, what can we conclude?”,
]

para q en test_queries: agent.process_query(q, verbose=True) time.sleep(0.5) agent.show_stats() print(“\nTutorial completo!”) print(“• El meta-razonamiento elige cómo pensar”) print(“• Diferentes consultas necesitan diferentes estrategias”) print(“• Los agentes inteligentes adaptan el razonamiento dinámicamente\n”)

Creamos un ejecutor de demostración para mostrar las capacidades del agente. Le alimentamos diversas consultas y observamos cómo selecciona su estrategia y genera respuestas. A medida que interactuamos con él, experimentamos de primera mano los beneficios del razonamiento adaptativo. Consulte el CUADERNO DE CÓDIGO COMPLETO.

si __nombre__ == “__main__”: run_tutorial()

Inicializamos todo el tutorial con un bloque principal simple. Realizamos la demostración y observamos todo el proceso de metarazonamiento en acción. A medida que ejecutamos esto, completamos el viaje desde el diseño hasta un agente adaptativo en pleno funcionamiento.

En conclusión, vemos cómo la construcción de un agente de metarazonamiento nos permite ir más allá de las respuestas de patrones fijos y hacia la inteligencia adaptativa. Observamos cómo el agente analiza cada consulta, selecciona el modo de razonamiento más apropiado y lo ejecuta de manera eficiente mientras rastrea su propio desempeño. Al diseñar y experimentar con estos componentes, obtenemos información práctica sobre cómo los agentes avanzados pueden autorregular su pensamiento, optimizar el esfuerzo y ofrecer mejores resultados.

Consulte el CUADERNO DE CÓDIGO COMPLETO. 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 emprendedor 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.