puntuaciones = resultado[‘critic_scores’]
incertidumbre = resultado[‘uncertainty’]
idx_seleccionado = resultado[‘selected_index’]
hacha = ejes[0, 0]
valores_puntuación = [s.overall_score for s in scores]
barras = ax.bar(rango(len(puntuaciones)), valores_puntuación, alfa=0,7) barras[selected_idx].set_color(‘verde’) barras[selected_idx].set_alpha(1.0) ax.axhline(np.mean(score_values), color=”red”, linestyle=”–“, label=f’Mean: {np.mean(score_values):.3f}’) ax.set_xlabel(‘Índice de respuestas’) ax.set_ylabel(‘Puntuación crítica’) ax.set_title(‘Puntuaciones críticas para cada respuesta’) ax.legend() ax.grid(Verdadero, alfa=0.3) ax = ejes[0, 1]
confidencias = [r.confidence for r in responses]
barras = ax.bar(rango(len(respuestas)), confidencias, alfa=0.7, color=”naranja”) barras[selected_idx].set_color(‘verde’) barras[selected_idx].set_alpha(1.0) ax.axhline(np.mean(confianzas), color=”red”, linestyle=”–“, label=f’Mean: {np.mean(confianzas):.3f}’) ax.set_xlabel(‘Índice de respuesta’) ax.set_ylabel(‘Confianza’) ax.set_title(‘Confianza del modelo por respuesta’) ax.legend() ax.grid(Verdadero, alfa=0.3) ax = ejes[1, 0]
componentes = { ‘Precisión’: [s.accuracy_score for s in scores]’Coherencia’: [s.coherence_score for s in scores]’Seguridad’: [s.safety_score for s in scores]
} x = np.arange(len(respuestas)) ancho = 0,25 para i, (nombre, valores) en enumerar(components.items()): desplazamiento = (i – 1) * ancho ax.bar(x + desplazamiento, valores, ancho, etiqueta=nombre, alfa=0,8) ax.set_xlabel(‘Índice de respuestas’) ax.set_ylabel(‘Puntuación’) ax.set_title(‘Componentes de puntuación crítica’) ax.set_xticks(x) ax.legend() ax.grid(True, alpha=0.3, axis=”y”) ax = ejes[1, 1]
incertidumbre_metrics = { ‘Entropía’: incertidumbre.entropía, ‘Varianza’: incertidumbre.varianza, ‘Consistencia’: incertidumbre.consistencia_score, ‘Epistemica’: incertidumbre.epistemic_incertainty, ‘Aleatoric’: incertidumbre.aleatoric_incertainty } barras = ax.barh(list(uncertainty_metrics.keys()), list(uncertainty_metrics.values()), alpha=0.7) ax.set_xlabel(‘Valor’) ax.set_title(f’Estimaciones de incertidumbre (Riesgo: {uncertainty.risk_level()})’) ax.grid(True, alpha=0.3, axis=”x”) plt.tight_layout() plt.show() @staticmethod def plot_strategy_comparison(agente: CriticAugmentedAgent, mensaje: str, ground_truth: Opcional[str] = Ninguno): estrategias = [“best_score”, “most_confident”, “most_consistent”, “risk_adjusted”]
resultados = {} print(“Comparando estrategias de selección…\n”) para estrategia en estrategias: print(f”Estrategia de prueba: {estrategia}”) resultado = agente.generate_with_critic(prompt, ground_truth, estrategia=estrategia, detallado=False) resultados[strategy] = resultado fig, ejes = plt.subplots(1, 2, figsize=(14, 5)) fig.suptitle(‘Comparación de estrategias’, fontsize=16, fontweight=”bold”) ax = ejes[0]
puntuaciones_seleccionadas = [
results[s][‘critic_scores’][results[s][‘selected_index’]].overall_score para s en estrategias ]bars = ax.bar(strategies, selected_scores, alpha=0.7, color=”steelblue”) ax.set_ylabel(‘Puntuación crítica’) ax.set_title(‘Calidad de respuesta seleccionada por estrategia’) ax.set_xticklabels(strategies, rotation=45, ha=”right”) ax.grid(True, alfa=0.3, eje=”y”) ax = ejes[1]
para estrategia en estrategias: resultado = resultados[strategy]
idx_seleccionado = resultado[‘selected_index’]
confianza = resultado[‘all_responses’][selected_idx].puntaje de confianza = resultado[‘critic_scores’][selected_idx].overall_score ax.scatter(confianza, puntuación, s=200, alfa=0,6, etiqueta=estrategia) ax.set_xlabel(‘Confianza’) ax.set_ylabel(‘Puntuación crítica’) ax.set_title(‘Compensación entre confianza y calidad’) ax.legend() ax.grid(Verdadero, alfa=0,3) plt.tight_layout() plt.show() devuelve resultados def run_basic_demo(): print(“\n” + “=” * 80) print(“DEMO 1: Agente básico con crítico”) print(“=” * 80 + “\n”) agente = CriticAugmentedAgent( model_quality=0.8, Risk_tolerance=0.3, n_samples=5 ) Prompt = “¿Qué es 15 + 27?” ground_truth = “42” resultado = agente.generate_with_critic( Prompt=prompt, ground_truth=ground_truth, estrategia=”risk_adjusted”, temperatura=0.8 ) print(“\n📊 Generando visualizaciones…”) AgentAnalyzer.plot_response_distribution(resultado) devuelve resultado def run_strategy_comparison(): print(“\n” + “=” * 80) print(“DEMO 2: Comparación de estrategias”) print(“=” * 80 + “\n”) agente = CriticAugmentedAgent( model_quality=0.75, Risk_tolerance=0.5, n_samples=6 ) Prompt = “¿Cuánto es 23 + 19?” ground_truth = “42” resultados = AgentAnalyzer.plot_strategy_comparison(agent, Prompt, ground_truth) devuelve resultados def run_uncertainty_analysis(): print(“\n” + “=” * 80) print(“DEMO 3: Análisis de incertidumbre”) print(“=” * 80 + “\n”) fig, axes = plt.subplots(1, 2, tamaño de higo=(14, 5)) cualidades = [0.5, 0.6, 0.7, 0.8, 0.9]
incertidumbres = []
consistencias = []
mensaje = “¿Cuánto es 30 + 12?” print(“Probando el impacto de la calidad del modelo en la incertidumbre…\n”) para la calidad en cualidades: agente = CriticAugmentedAgent(model_quality=quality, n_samples=8) result = agent.generate_with_critic(prompt, verbose=False) incertidumbres.append(resultado[‘uncertainty’].entropía) consistencias.append(resultado[‘uncertainty’].consistency_score) print(f”Calidad: {calidad:.1f} -> Entropía: {resultado[‘uncertainty’].entropía:.3f}, “f”Consistencia: {resultado[‘uncertainty’].consistency_score:.3f}”) ax = ejes[0]
ax.plot(cualidades, incertidumbres, ‘o-‘, ancho de línea=2, tamaño de marcador=8, etiqueta=”Entropía”) ax.set_xlabel(‘Calidad del modelo’) ax.set_ylabel(‘Entropía’) ax.set_title(‘Incertidumbre vs calidad del modelo’) ax.grid(True, alpha=0.3) ax.legend() ax = axes[1]
ax.plot(cualidades, consistencias, ‘s-‘, ancho de línea=2, tamaño de marcador=8, color=”verde”, etiqueta=”Consistencia”) ax.set_xlabel(‘Calidad del modelo’) ax.set_ylabel(‘Puntuación de consistencia’) ax.set_title(‘Autoconsistencia vs calidad del modelo’) ax.grid(True, alpha=0.3) ax.legend() plt.tight_layout() plt.show() def run_risk_sensitivity_demo(): print(“\n” + “=” * 80) print(“DEMO 4: Análisis de sensibilidad al riesgo”) print(“=” * 80 + “\n”) solicitud = “¿Qué es 18 + 24?” tolerancias_riesgo = [0.1, 0.3, 0.5, 0.7, 0.9]
resultados = {‘tolerancia_riesgo’: []’confianza_seleccionada’: []’puntuación_seleccionada’: []’incertidumbre’: []
} print(“Probando diferentes niveles de tolerancia al riesgo…\n”) para Risk_tol en Risk_tolerances: agente = CriticAugmentedAgent( model_quality=0.75, Risk_tolerance=risk_tol, n_samples=6 ) resultado = agente.generate_with_critic(prompt, detallado=False) selected_idx = resultado[‘selected_index’]
resultados[‘risk_tolerance’].append(risk_tol) resultados[‘selected_confidence’].append(resultado[‘all_responses’][selected_idx].confianza) resultados[‘selected_score’].append(resultado[‘critic_scores’][selected_idx].puntuación_general) resultados[‘uncertainty’].append(resultado[‘uncertainty’].entropy) print(f”Tolerancia al riesgo: {risk_tol:.1f} -> ” f”Confianza: {resultados[‘selected_confidence’][-1]:.3f}, ” f”Puntuación: {resultados[‘selected_score’][-1]:.3f}”) fig, ax = plt.subplots(1, 1, figsize=(10, 6)) ax.plot(resultados[‘risk_tolerance’]resultados[‘selected_confidence’]’o-‘, ancho de línea = 2, tamaño de marcador = 8, etiqueta = “Confianza seleccionada”) ax.plot (resultados[‘risk_tolerance’]resultados[‘selected_score’]’s-‘, ancho de línea=2, tamaño de marcador=8, etiqueta=”Puntuación seleccionada”) ax.set_xlabel(‘Tolerancia al riesgo’) ax.set_ylabel(‘Valor’) ax.set_title(‘Impacto de la tolerancia al riesgo en la selección’) ax.legend() ax.grid(True, alpha=0.3) plt.tight_layout() plt.show() def demostrar_incertidumbre_verbalizada(): print(“\n” + “=” * 80) print(“TEMA DE INVESTIGACIÓN: Incertidumbre verbalizada”) print(“=” * 80 + “\n”) print(“Concepto: El agente no sólo estima la incertidumbre sino que la explica.\n”) agente = CriticAugmentedAgent(model_quality=0.7, n_samples=5) Prompt = “¿Cuánto es 25 + 17?” resultado = agente.generar_con_crítico (mensaje, detallado = Falso) incertidumbre = resultado[‘uncertainty’]
explicación = f””” Informe de análisis de incertidumbre: ————————— Nivel de riesgo: {uncertainty.risk_level()} Desglose detallado: • Entropía de respuesta: {incertidumbre.entropy:.3f} → {‘Bajo’ si incertidumbre.entropía < 0,5 más 'Medio' si incertidumbre.entropía < 1,0 más 'Alto'} desacuerdo entre las respuestas generadas • Autoconsistencia: {uncertainty.consistency_score:.3f} → {int(uncertainty.consistency_score * 100)}% de las respuestas coinciden en la respuesta • Incertidumbre epistémica: {uncertainty.epistemic_uncertainty:.3f} → {'Baja' si incertidumbre.epistemic_uncertainty < 0.3 else 'Media' si incertidumbre.epistemic_uncertainty < 0.6 else 'Alta'} incertidumbre del modelo (brechas de conocimiento) • Incertidumbre aleatoria: {incertidumbre.aleatoric_uncertainty:.3f} → {'Baja' si incertidumbre.aleatoric_uncertainty < 0.3 else 'Media' si incertidumbre.aleatoric_uncertainty < 0.6 else 'Alta'} incertidumbre de los datos (aleatoriedad inherente) Recomendación: """ si incertidumbre.risk_level() == "BAJO": explicación += " ✓ Alta confianza en la respuesta - seguro para confiar" elif incertidumbre.risk_level() == "MEDIO": explicación += "⚠ Confianza moderada - considere la verificación" else: explicación += "⚠ Confianza baja - recomiendo encarecidamente la verificación" print(explicación) def demostrar_self_consistency(): print("\n" + "=" * 80) print("TEMA DE INVESTIGACIÓN: Razonamiento de autoconsistencia") print("=" * 80 + "\n") print("Concepto: generar múltiples rutas de razonamiento, seleccionar la respuesta más común.\n") agente = CriticAugmentedAgent(model_quality=0.75, n_samples=7) solicitud = "¿Cuánto es 35 + 7?" resultado = agente.generate_with_critic(prompt, estrategia="most_consistent", verbose=False) estimador = UncertaintyEstimator() respuestas = [estimator._extract_answer(r.content) for r in result['all_responses']]print("Respuestas generadas y respuestas:") print("-" * 80) para i, (respuesta, respuesta) en enumerar(zip(resultado['all_responses']respuestas)): marcador = " ✓ SELECCIONADO " si i == resultado['selected_index'] else "" print(f"\nRespuesta {i}: {respuesta} {marcador}") print(f" Confianza: {respuesta.confianza:.3f}") print(f" Contenido: {respuesta.content[:80]}...") de colecciones importar Contador respuesta_dist = Contador(respuestas) print(f"\n\nDistribución de respuestas:") print("-" * 80) para respuesta, cuenta en respuesta_dist.most_common(): porcentaje = (recuento / len(respuestas)) * 100 bar = "█" * int(porcentaje / 5) print(f"{respuesta:>10}: {bar} {count}/{len(answers)} ({percentage:.1f}%)”) print(f”\nRespuesta más consistente: {answer_dist.most_common(1)[0][0]}”) print(f”Puntuación de coherencia: {resultado[‘uncertainty’].consistency_score:.3f}”) def main(): print(“\n” + “🎯” * 40) print(“AGENTE AVANZADO CON CRÍTICA INTERNA + ESTIMACIÓN DE INCERTIDUMBRE”) print(“Tutorial y demostraciones”) print(“🎯” * 40) plt.style.use(‘seaborn-v0_8-darkgrid’) sns.set_palette(“husl”) intente: resultado1 = run_basic_demo() resultado2 = run_strategy_comparison() run_uncertainty_analysis() run_risk_sensitivity_demo() demostrar_verbalizado_incertidumbre() demostrar_self_consistency() print(“\n” + “=” * 80) print(“✅ TODAS LAS DEMOSTRACIONES COMPLETADAS CON ÉXITO”) print(“=” * 80) print(“”” Conclusiones clave: 1. Los críticos internos mejoran la calidad de la respuesta a través de una evaluación multidimensional 2. La estimación de la incertidumbre permite la toma de decisiones consciente del riesgo 3. El razonamiento de autoconsistencia aumenta la confiabilidad 4. Las diferentes estrategias de selección se optimizan para diferentes objetivos 5. La incertidumbre verbalizada ayuda a los usuarios a comprender la confianza del modelo Próximos pasos: • Implementar con API LLM reales (OpenAI, Anthropic, etc.) • Agregar modelos críticos aprendidos (afinados) clasificadores) • Explorar métodos de conjunto y metaaprendizaje • Integrar con generación de recuperación aumentada (RAG) • Implementar en producción con ciclos de monitoreo y retroalimentación “””) excepto Excepción como e: print(f”\n❌ Error durante la demostración: {e}”) import traceback traceback.print_exc() if __name__ == “__main__”: main()