AIGC 领域多智能体系统的狼群算法应用

    import numpy as np
    from typing import List, Tuple
    
    class Wolf:
    def __init__(self, position: np.ndarray, role: str):
        self.position = position  # 当前解决方案
        self.role = role          # 角色: leader, explorer, killer
        self.fitness = 0.0        # 解决方案质量
        
    class WolfPackAIGC:
    def __init__(self, 
                 n_wolves: int, 
                 search_space: Tuple[float, float],
                 max_iter: int = 100):
        self.wolves = []          # 狼群个体集合
        self.alpha = None         # 头狼(最优解)
        self.beta = None          # 次优解
        self.delta = None         # 第三优解
        self.max_iter = max_iter  # 最大迭代次数
        self.search_space = search_space
        
    def initialize_wolves(self, n_wolves: int):
        """初始化狼群位置和角色"""
        for i in range(n_wolves):
            position = np.random.uniform(*self.search_space)
            role = 'explorer' if i < n_wolves//3 else 'killer' if i < 2*n_wolves//3 else 'leader'
            self.wolves.append(Wolf(position, role))
    
    def evaluate_fitness(self, wolf: Wolf) -> float:
        """评估解决方案质量"""
        # 这里应根据具体AIGC任务定义评估函数
        # 例如: 生成内容的质量评分、多样性、创新性等
        return -np.sum(wolf.position**2)  # 示例: 简单优化问题
    
    def hunting_behavior(self):
        """狼群狩猎行为模拟"""
        # 1. 游走行为(探索阶段)
        explorers = [w for w in self.wolves if w.role == 'explorer']
        for wolf in explorers:
            new_pos = wolf.position + np.random.normal(0, 0.1, size=wolf.position.shape)
            wolf.position = np.clip(new_pos, *self.search_space)
            wolf.fitness = self.evaluate_fitness(wolf)
        
        # 2. 召唤行为(开发阶段)
        killers = [w for w in self.wolves if w.role == 'killer']
        for wolf in killers:
            direction = self.alpha.position - wolf.position
            new_pos = wolf.position + 0.5 * direction
            wolf.position = np.clip(new_pos, *self.search_space)
            wolf.fitness = self.evaluate_fitness(wolf)
        
        # 3. 围攻行为(局部优化)
        leaders = [w for w in self.wolves if w.role == 'leader']
        for wolf in leaders:
            r1, r2 = np.random.random(), np.random.random()
            A1 = 2 * 1 * r1 - 1  # 收敛因子
            C1 = 2 * r2
            D_alpha = abs(C1 * self.alpha.position - wolf.position)
            new_pos = self.alpha.position - A1 * D_alpha
            wolf.position = np.clip(new_pos, *self.search_space)
            wolf.fitness = self.evaluate_fitness(wolf)
    
    def update_hierarchy(self):
        """更新狼群社会等级"""
        sorted_wolves = sorted(self.wolves, key=lambda x: x.fitness, reverse=True)
        self.alpha = sorted_wolves[0]
        self.beta = sorted_wolves[1]
        self.delta = sorted_wolves[2]
        
        # 动态角色调整
        for i, wolf in enumerate(self.wolves):
            if i < len(self.wolves)//3:
                wolf.role = 'explorer'
            elif i < 2*len(self.wolves)//3:
                wolf.role = 'killer'
            else:
                wolf.role = 'leader'
    
    def optimize(self):
        """执行优化过程"""
        self.initialize_wolves(len(self.wolves))
        for wolf in self.wolves:
            wolf.fitness = self.evaluate_fitness(wolf)
        self.update_hierarchy()
        
        for iter in range(self.max_iter):
            self.hunting_behavior()
            self.update_hierarchy()
            print(f"Iter {iter}: Best fitness = {self.alpha.fitness:.4f}")
        
        return self.alpha.position
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/hFzZW1tkS850wm4KYbBGJOdMsf6X.png)

    # 创建Python虚拟环境
    python -m venv wpa_aigc
    source wpa_aigc/bin/activate  # Linux/Mac
    wpa_aigc\Scripts\activate     # Windows
    
    # 安装依赖
    pip install numpy matplotlib openai tqdm
    
    
    bash

    import openai
    from tqdm import tqdm
    
    class AIGCWolfPackOptimizer:
    def __init__(self, api_key, target_theme, n_wolves=10, dim=5):
        openai.api_key = api_key
        self.target = target_theme
        self.n_wolves = n_wolves
        self.dim = dim  # 提示词向量维度
        self.wolves = []
        
    def initialize_wolves(self):
        """初始化狼群，每个狼代表一组提示词权重"""
        for i in range(self.n_wolves):
            position = np.random.uniform(-1, 1, size=self.dim)
            role = 'explorer' if i < self.n_wolves//3 else 'killer' if i < 2*self.n_wolves//3 else 'leader'
            self.wolves.append(Wolf(position, role))
    
    def generate_content(self, prompt_weights) -> str:
        """使用当前提示词权重生成内容"""
        prompt = self._build_prompt(prompt_weights)
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=prompt,
            max_tokens=200
        )
        return response.choices[0].text.strip()
    
    def _build_prompt(self, weights) -> str:
        """构建加权提示词"""
        themes = ["creative", "detailed", "technical", "emotional", "concise"]
        weighted_theme = " ".join(f"{w:.2f}*{t}" for w, t in zip(weights, themes))
        return f"Write a {weighted_theme} article about {self.target}"
    
    def evaluate_fitness(self, wolf: Wolf) -> float:
        """评估生成内容的质量"""
        content = self.generate_content(wolf.position)
        
        # 1. 主题相关性评估
        relevance_score = self._evaluate_relevance(content)
        
        # 2. 内容质量评估
        quality_score = self._evaluate_quality(content)
        
        # 3. 多样性惩罚项
        diversity_penalty = 0.1 * np.sum(wolf.position**2)
        
        return relevance_score + quality_score - diversity_penalty
    
    def _evaluate_relevance(self, content: str) -> float:
        """使用嵌入模型评估内容与目标主题的相关性"""
        # 简化的评估函数，实际应使用嵌入模型
        keywords = self.target.lower().split()
        content_words = content.lower().split()
        matches = sum(1 for kw in keywords if kw in content_words)
        return matches / len(keywords)
    
    def _evaluate_quality(self, content: str) -> float:
        """评估内容的语言质量"""
        # 简化的质量评估，实际可使用语言模型
        sentence_count = len([c for c in content if c in '.!?'])
        word_count = len(content.split())
        if word_count == 0:
            return 0
        return min(1.0, sentence_count / (word_count / 15))  # 句子密度指标
    
    def optimize_prompts(self, max_iter=20):
        """执行提示词优化"""
        self.initialize_wolves()
        for wolf in self.wolves:
            wolf.fitness = self.evaluate_fitness(wolf)
        self.update_hierarchy()
        
        best_scores = []
        with tqdm(range(max_iter)) as pbar:
            for _ in pbar:
                self.hunting_behavior()
                self.update_hierarchy()
                best_scores.append(self.alpha.fitness)
                pbar.set_description(f"Best score: {self.alpha.fitness:.2f}")
                
        # 输出最佳提示词组合
        best_weights = self.alpha.position
        print("\nOptimized prompt weights:")
        themes = ["creative", "detailed", "technical", "emotional", "concise"]
        for t, w in zip(themes, best_weights):
            print(f"{t}: {w:.2f}")
        
        return best_weights, best_scores
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/B56rvyqpJL7twUMKEjT3HcikCNhP.png)

 * 创建狼群个体，每个个体代表一组提示词权重向量
 * 随机初始化权重值在[-1,1]范围内

 * 使用OpenAI API根据加权提示词生成内容
 * 提示词由多个维度(创意性、细节度等)加权组合

 * 主题相关性：计算生成内容中目标关键词的出现频率
 * 内容质量：分析句子结构和词汇多样性
 * 多样性惩罚：防止权重过度集中于单一维度

 * 通过狼群的三种行为模式探索提示词权重空间
 * 动态调整社会等级确保持续优化
 * 可视化显示优化进度曲线

    # 使用示例
    optimizer = AIGCWolfPackOptimizer(api_key="your_api_key", 
                                 target_theme="renewable energy")
    best_weights, scores = optimizer.optimize_prompts()
    
    # 绘制优化曲线
    import matplotlib.pyplot as plt
    plt.plot(scores)
    plt.title("WPA Optimization Progress")
    plt.xlabel("Iteration")
    plt.ylabel("Content Quality Score")
    plt.show()
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/Xl80bVukosUfN6DZ9cvtxm5qyp7B.png)