#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 最优路径算法脚本 功能：寻找能够实现全局最优的路径 用途：当AI Agent需要寻找最优路径时调用 参数：问题定义、约束条件、优化目标 输出：最优路径、多个备选方案、优化建议 """ import json import argparse from typing import Dict, List, Any, Optional, Tuple from dataclasses import dataclass from enum import Enum class OptimizationType(Enum): """优化类型""" MAXIMIZE = "maximize" # 最大化 MINIMIZE = "minimize" # 最小化 @dataclass class Constraint: """约束条件""" name: str description: str type: str # 'equality', 'inequality', 'range' value: Any @dataclass class OptimizationObjective: """优化目标""" name: str type: OptimizationType weight: float # 权重 (0-1) description: str @dataclass class PathNode: """路径节点""" step: int action: str expected_outcome: str entropy_reduction: float # 熵减效果 value_creation: float # 价值创造 system_optimization: float # 系统优化 @dataclass class OptimalPath: """最优路径""" nodes: List[PathNode] total_score: float entropy_reduction_total: float value_creation_total: float system_optimization_total: float @dataclass class OptimalPathResult: """最优路径分析结果""" optimal_path: OptimalPath alternative_paths: List[OptimalPath] analysis: Dict[str, Any] recommendations: List[str] class OptimalPathFinder: """最优路径查找器""" def __init__(self): self.default_weights = { 'entropy_reduction': 0.35, 'value_creation': 0.35, 'system_optimization': 0.30 } def find_optimal_path(self, problem_definition: str, constraints: List[Constraint], objectives: List[OptimizationObjective], current_state: Dict[str, Any] = None) -> OptimalPathResult: """ 寻找最优路径 Args: problem_definition: 问题定义 constraints: 约束条件列表 objectives: 优化目标列表 current_state: 当前状态 Returns: OptimalPathResult: 最优路径分析结果 """ # 生成可能的路径方案 possible_paths = self._generate_possible_paths( problem_definition, constraints, objectives, current_state ) # 评估每个路径 evaluated_paths = [self._evaluate_path(path, objectives) for path in possible_paths] # 选择最优路径 optimal_path = self._select_optimal_path(evaluated_paths) # 生成备选路径 alternative_paths = self._select_alternative_paths(evaluated_paths, optimal_path) # 分析 analysis = self._analyze_paths(evaluated_paths, optimal_path) # 生成建议 recommendations = self._generate_recommendations(optimal_path, analysis) return OptimalPathResult( optimal_path=optimal_path, alternative_paths=alternative_paths, analysis=analysis, recommendations=recommendations ) def _generate_possible_paths(self, problem: str, constraints: List[Constraint], objectives: List[OptimizationObjective], current_state: Dict[str, Any] = None) -> List[List[PathNode]]: """生成可能的路径方案""" # 这里提供路径生成框架，具体的路径生成由AI Agent完成 # 返回几种典型路径模式 # 路径1：第一性原理驱动的路径 path1 = [ PathNode(1, "用第一性原理分析问题", "识别根本前提", 0.4, 0.3, 0.3), PathNode(2, "从根本前提出发构建方案", "构建基础框架", 0.3, 0.4, 0.3), PathNode(3, "用熵减思维评估每个决策", "建立最大秩序", 0.4, 0.3, 0.4), PathNode(4, "执行最优方案", "实现全局最优", 0.3, 0.4, 0.4) ] # 路径2：系统优化的路径 path2 = [ PathNode(1, "从系统整体角度理解问题", "把握全局", 0.3, 0.4, 0.4), PathNode(2, "识别系统的关键节点", "找到杠杆点", 0.4, 0.3, 0.3), PathNode(3, "优化关键节点的连接", "提升系统效率", 0.3, 0.4, 0.4), PathNode(4, "实现系统整体优化", "全局最优", 0.3, 0.4, 0.4) ] # 路径3：渐进优化的路径（不推荐） path3 = [ PathNode(1, "分析当前问题", "局部理解", 0.2, 0.2, 0.2), PathNode(2, "提出改进方案", "小步优化", 0.1, 0.3, 0.1), PathNode(3, "执行并测试", "验证效果", 0.1, 0.2, 0.1), PathNode(4, "继续迭代", "渐进改善", 0.1, 0.2, 0.1) ] return [path1, path2, path3] def _evaluate_path(self, path: List[PathNode], objectives: List[OptimizationObjective]) -> Tuple[List[PathNode], float]: """评估路径得分""" # 计算总分 entropy_reduction_total = sum(node.entropy_reduction for node in path) value_creation_total = sum(node.value_creation for node in path) system_optimization_total = sum(node.system_optimization for node in path) # 根据权重计算总分 total_score = ( entropy_reduction_total * self.default_weights['entropy_reduction'] + value_creation_total * self.default_weights['value_creation'] + system_optimization_total * self.default_weights['system_optimization'] ) # 创建最优路径对象 optimal_path = OptimalPath( nodes=path, total_score=total_score, entropy_reduction_total=entropy_reduction_total, value_creation_total=value_creation_total, system_optimization_total=system_optimization_total ) return optimal_path, total_score def _select_optimal_path(self, evaluated_paths: List[OptimalPath]) -> OptimalPath: """选择最优路径""" return max(evaluated_paths, key=lambda x: x.total_score) def _select_alternative_paths(self, evaluated_paths: List[OptimalPath], optimal: OptimalPath) -> List[OptimalPath]: """选择备选路径""" # 排除最优路径，选择前2个备选 alternatives = [path for path in evaluated_paths if path != optimal] alternatives.sort(key=lambda x: x.total_score, reverse=True) return alternatives[:2] def _analyze_paths(self, evaluated_paths: List[OptimalPath], optimal: OptimalPath) -> Dict[str, Any]: """分析路径""" return { 'total_paths': len(evaluated_paths), 'optimal_score': optimal.total_score, 'optimal_entropy_reduction': optimal.entropy_reduction_total, 'optimal_value_creation': optimal.value_creation_total, 'optimal_system_optimization': optimal.system_optimization_total, 'score_range': { 'min': min(p.total_score for p in evaluated_paths), 'max': max(p.total_score for p in evaluated_paths), 'average': sum(p.total_score for p in evaluated_paths) / len(evaluated_paths) }, 'advantage_over_average': optimal.total_score - sum(p.total_score for p in evaluated_paths) / len(evaluated_paths) } def _generate_recommendations(self, optimal: OptimalPath, analysis: Dict[str, Any]) -> List[str]: """生成建议""" recommendations = [] # 最优路径建议 recommendations.append(f"✓ 推荐路径: 总分 {optimal.total_score:.3f}") recommendations.append(f" - 熵减效果: {optimal.entropy_reduction_total:.3f}") recommendations.append(f" - 价值创造: {optimal.value_creation_total:.3f}") recommendations.append(f" - 系统优化: {optimal.system_optimization_total:.3f}") # 步骤建议 recommendations.append("\n执行步骤:") for i, node in enumerate(optimal.nodes, 1): recommendations.append(f" 步骤{i}: {node.action} -> {node.expected_outcome}") # 一般性建议 recommendations.extend([ "\n原则:", "- 不满足于局部最优，追求全局最优", "- 不满足于线性改善，追求根本性突破", "- 不满足于单一方案，追求多维度协同", "- 用第一性原理、熵减、最优算法、最优路径全面打透" ]) return recommendations def main(): """主函数""" parser = argparse.ArgumentParser(description='最优路径查找工具') parser.add_argument('--problem', type=str, required=True, help='问题定义') parser.add_argument('--output', type=str, default='json', choices=['json', 'text'], help='输出格式') args = parser.parse_args() # 创建约束条件示例 constraints = [ Constraint("资源约束", "有限的资源必须高效利用", "range", (0, 1)), Constraint("时间约束", "必须在合理时间内完成", "inequality", "< 1.0") ] # 创建优化目标 objectives = [ OptimizationObjective("熵减", OptimizationType.MAXIMIZE, 0.35, "最大化熵减效果"), OptimizationObjective("价值创造", OptimizationType.MAXIMIZE, 0.35, "最大化价值创造"), OptimizationObjective("系统优化", OptimizationType.MAXIMIZE, 0.30, "最大化系统优化") ] # 创建查找器 finder = OptimalPathFinder() # 执行查找 result = finder.find_optimal_path(args.problem, constraints, objectives) # 输出结果 if args.output == 'json': print(json.dumps({ 'optimal_path': { 'total_score': result.optimal_path.total_score, 'nodes': [ { 'step': node.step, 'action': node.action, 'expected_outcome': node.expected_outcome } for node in result.optimal_path.nodes ] }, 'analysis': result.analysis, 'recommendations': result.recommendations }, ensure_ascii=False, indent=2)) else: print(f"问题: {args.problem}\n") print(f"最优路径总分: {result.optimal_path.total_score:.3f}\n") print("执行步骤:") for i, node in enumerate(result.optimal_path.nodes, 1): print(f" {i}. {node.action}") print(f" 预期结果: {node.expected_outcome}") print("\n备选路径:") for i, path in enumerate(result.alternative_paths, 1): print(f" 备选{i}: 总分 {path.total_score:.3f}") print("\n建议:") for rec in result.recommendations: print(f" {rec}") if __name__ == '__main__': main()