En este tutorial, construimos un agente de control metacognitivo avanzado que aprende a regular su propia profundidad de pensamiento. Tratamos el razonamiento como un espectro, que va desde heurísticas rápidas hasta cadenas de pensamiento profundas y soluciones precisas similares a herramientas, y entrenamos un metacontrolador neuronal para decidir qué modo usar para cada tarea. Al optimizar el equilibrio entre precisión, costo de cálculo y un presupuesto de razonamiento limitado, exploramos cómo un agente puede monitorear su estado interno y adaptar su estrategia de razonamiento en tiempo real. A través de cada fragmento, experimentamos, observamos patrones y entendemos cómo surge la metacognición cuando un agente aprende a pensar sobre su propio pensamiento. Consulte el CUADERNO DE CÓDIGO COMPLETO.
def make_task(): op = random.choice(OPS) if op == ‘+’: a, b = random.randint(1, 99), random.randint(1, 99) else: a, b = random.randint(2, 19), random.randint(2, 19) devuelve a, b, op def true_answer(a, b, op): devuelve a + b si op == ‘+’ else a * b def dificultad_verdadera(a, b, op): si op == ‘+’ y a <= 30 y b <= 30: devuelve 0 si op == '*' y a <= 10 y b <= 10: devuelve 1 devuelve 2 def dificultad_heurística(a, b, op): puntuación = 0 si op == '*': puntuación += 0,6 puntuación += max(a, b) / 100.0 return min(score, 1.0) def fast_heuristic(a, b, op): if op == '+': base = a + b ruido = random.choice([-2, -1, 0, 0, 0, 1, 2, 3]) más: base = int(0.8 * a * b) ruido = elección aleatoria ([-5, -3, 0, 0, 2, 5, 8]) devolver base + ruido, 0.5 def cadena_profunda_de_pensamiento(a, b, op, verbose=False): if op == '+': x, y = a, b carry = 0 pos = 1 resultado = 0 paso = 0 mientras x > 0 o y > 0 o carry: dx, dy = x % 10, y % 10 s = dx + dy + carry carry, dígito = divmod(s, 10) resultado += dígito * pos x //= 10; y //= 10; pos *= 10 paso += 1 else: resultado = 0 paso = 0 para i, d en enumerar(reversed(str(b))): fila = a * int(d) * (10 ** i) resultado += fila paso += 1 devolver resultado, max(2.0, 0.4 * paso) def tool_solver(a, b, op): return eval(f”{a}{op}{b}”), 1.2 ACTION_NAMES = [“fast”, “deep”, “tool”]
Configuramos el mundo en el que opera nuestro metaagente. Generamos tareas aritméticas, definimos respuestas reales, estimamos la dificultad e implementamos tres modos de razonamiento diferentes. Mientras lo ejecutamos, observamos cómo cada solucionador se comporta de manera diferente en términos de precisión y costo computacional, que forman la base del espacio de decisión del agente. Consulte el CUADERNO DE CÓDIGO COMPLETO.
si last_action no es Ninguno: last_onehot[last_action] = 1.0 hazañas = [
a_n, b_n, op_plus, op_mul,
diff_hat, rem_n, error_ema
] + last_onehot return torch.tensor(feats, dtype=torch.float32, dispositivo=dispositivo) STATE_DIM = 10 N_ACTIONS = 3 clase PolicyNet(nn.Module): def __init__(self, state_dim, oculto=48, n_actions=3): super().__init__() self.net = nn.Sequential( nn.Linear(state_dim, oculto), nn.Tanh(), nn.Linear(oculto, oculto), nn.Tanh(), nn.Linear(oculto, n_actions) ) def forward(self, x): devolver self.net(x) política = PolicyNet(STATE_DIM, oculto=48, n_actions=N_ACTIONS).to(dispositivo) optimizador = optim.Adam(policy.parameters(), lr=3e-3)
Codificamos cada tarea en un estado estructurado que captura operandos, tipo de operación, dificultad prevista, presupuesto restante y rendimiento reciente. Luego definimos una red de políticas neuronales que asigna este estado a una distribución de probabilidad sobre acciones. A medida que la analizamos, vemos cómo la política se convierte en el mecanismo central a través del cual el agente aprende a regular su pensamiento. Consulte el CUADERNO DE CÓDIGO COMPLETO.
recompensas = []
información = []
rem_budget = MAX_BUDGET error_ema = 0.0 last_action = Ninguno para _ en rango(STEPS_PER_EP): a, b, op = make_task() estado = encode_state(a, b, op, rem_budget, error_ema, last_action) logits = política(estado) dist = torch.distributions.Categorical(logits=logits) action = dist.sample() si entrena otra cosa torch.argmax(logits) act_idx = int(action.item()) if act_idx == 0: pred, costo = fast_heuristic(a, b, op) elif act_idx == 1: pred, costo = cadena_profunda_de_pensamiento(a, b, op, detallado=False) else: pred, costo = tool_solver(a, b, op) correcto = (pred == true_answer(a, b, op)) acc_reward = 1.0 si es correcto, de lo contrario 0.0 presupuesto_penalidad = 0.0 rem_budget -= costo si rem_budget < 0: presupuesto_penalidad = -1.5 * (abs(rem_presupuesto) / MAX_BUDGET) step_reward = acc_reward - COST_PENALTY * costo + presupuesto_penalidad recompensas.append(step_reward) si tren: log_probs.append(dist.log_prob(action)) err = 0.0 si es correcto else 1.0 error_ema = ERROR_EMA_DECAY * error_ema + (1 - ERROR_EMA_DECAY) * err last_action = act_idx info.append({ "correct": correcto, "coste": costo, "dificultad": true_difficulty(a, b, op), "acción": act_idx }) si tren: devuelve = [] G = 0.0 para r en invertido(recompensas): G = r + GAMMA * G return.append(G) return = list(reversed(returns)) return_t = torch.tensor(returns, dtype=torch.float32, dispositivo=dispositivo) línea base = regresa_t.mean() adv = regresa_t - pérdida de línea base = -(torch.stack(log_probs) * adv).mean() optimizador.zero_grad() loss.backward() optimizador.step() devolver recompensas, información
Implementamos el corazón del aprendizaje utilizando el algoritmo de gradiente de políticas REINFORCE. Ejecutamos episodios de varios pasos, recopilamos probabilidades de registros, acumulamos recompensas y calculamos retornos. A medida que ejecutamos esta parte, observamos al metacontrolador ajustar su estrategia reforzando decisiones que equilibran la precisión con el costo. Consulte el CUADERNO DE CÓDIGO COMPLETO.
a_idx = paso[“action”]
todas_acciones[d][a_idx] += 1 estadísticas[d][“n”] += 1 estadísticas[d][“acc”] += 1 si paso[“correct”] más 0 estadísticas[d][“cost”] += paso[“cost”]
para d en [0,1,2]: si estadísticas[d][“n”] == 0: continuar n = estadísticas[d][“n”]
print(f”Dificultad {d}:”) print(” la acción cuenta [fast, deep, tool]:”, todas_acciones[d]) print(“precisión:”, estadísticas[d][“acc”]/n) print(“coste promedio:”, estadísticas[d][“cost”]/n) print() print(“Comportamiento de la política por dificultad:”) evaluar()
Entrenamos al agente metacognitivo a lo largo de cientos de episodios y evaluamos su comportamiento en todos los niveles de dificultad. Observamos cómo evoluciona la política, utilizando heurísticas rápidas para tareas simples y recurriendo a razonamientos más profundos para las más difíciles. A medida que analizamos los resultados, entendemos cómo la capacitación da forma a las elecciones de razonamiento del agente. Consulte el CUADERNO DE CÓDIGO COMPLETO.
Inspeccionamos un rastreo de razonamiento detallado en busca de un ejemplo difícil elegido por la política capacitada. Vemos al agente elegir con confianza un modo y seguir los pasos del razonamiento, lo que nos permite presenciar su comportamiento metacognitivo en acción. A medida que probamos diferentes tareas, apreciamos cómo el modelo adapta su pensamiento en función del contexto.
En conclusión, hemos visto cómo un controlador neuronal puede aprender a elegir dinámicamente la vía de razonamiento más eficaz en función de la dificultad de la tarea y las limitaciones del momento. Observamos cómo el agente descubre gradualmente cuándo son suficientes las heurísticas rápidas, cuándo es necesario un razonamiento más profundo y cuándo vale la pena recurrir a un solucionador preciso. A través de este proceso, experimentamos cómo el control metacognitivo transforma la toma de decisiones, conduciendo a sistemas de razonamiento más eficientes y adaptables.
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 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.