第三阶段：进化与群体智能 (Evolutionary & Swarm Intelligence)

灵感: 来源于金属冶炼。高温时原子活跃（乱跳），低温时原子稳定（有序）。

策略: 为了跳出局部最优，允许以一定概率接受更差的解！

核心公式:

T(温度) 很高时，PPP 接近 1，大概率接受差解（到处乱跑，探索全局）。

T降低后，Refusing bad moves，逐渐收敛（精细搜索局部）。

1-2.实战代码 (Python 模拟退火)

我们要寻找函数的最小值（虽然是个简单凸函数，但演示原理足够）。

python 复制代码

import math
import random
def simulated_annealing(func, bounds, iterations, temp, cooling_rate):
    # 1. 随机初始化一个解
    current_x = random.uniform(bounds[0], bounds[1])
    current_val = func(current_x)
    
    best_x, best_val = current_x, current_val
    
    for i in range(iterations):
        # 2. 产生一个新解 (在当前解附近随机扰动)
        new_x = current_x + random.uniform(-1, 1)
        new_val = func(new_x)
        
        # 3. 判断是否接受新解
        if new_val < current_val:
            # 如果新解更好，直接接受
            current_x, current_val = new_x, new_val
            if new_val < best_val:
                best_x, best_val = new_x, new_val
        else:
            # 如果新解更差，按概率接受 (Metropolis准则)
            diff = new_val - current_val
            probability = math.exp(-diff / temp)
            if random.random() < probability:
                current_x, current_val = new_x, new_val
        
        # 4. 降温
        temp *= cooling_rate
        
    print(f"🌡️ 模拟退火结束: 最佳解 x={best_x:.4f}, y={best_val:.4f}")
# 测试: 寻找 y=x^2 的最小值
simulated_annealing(lambda x: x**2, bounds=[-10, 10], iterations=1000, temp=100, cooling_rate=0.95)

2. 进化计算 (Evolutionary Computation)

达尔文的胜利！优胜劣汰，适者生存。让代码自己"生孩子"、"变异"，一代比一代强。

2-1.核心理论

遗传算法 (Genetic Algorithm - GA):

染色体 (Chromosome): 问题的解被编码成一串数字（通常是 0/1 二进制串）。

种群 (Population): 一堆解放在一起。

适应度函数 (Fitness Function): 裁判，决定谁是"优良品种"。

三大算子 (The Big Three):

选择 (Selection): 轮盘赌 (Roulette Wheel) ------ 适应度越高，被选中的概率越大。

交叉 (Crossover): 父母各出一半基因，拼出新个体（探索新区域）。

变异 (Mutation): 随机改变基因的某一位（防止种群僵化，保持多样性）。

2-2.实战代码 (GA 核心逻辑)

用简单的二进制编码演示交叉和变异。

python 复制代码

import random

# 假设基因长度为 10
GENE_LENGTH = 10

def crossover(parent1, parent2):
    # 单点交叉: 随机选一个切点，交换尾部
    point = random.randint(1, GENE_LENGTH - 1)
    child1 = parent1[:point] + parent2[point:]
    child2 = parent2[:point] + parent1[point:]
    return child1, child2

def mutate(individual, mutation_rate=0.01):
    # 变异: 遍历每一位，按概率翻转 (0->1, 1->0)
    gene_list = list(individual)
    for i in range(len(gene_list)):
        if random.random() < mutation_rate:
            gene_list[i] = '1' if gene_list[i] == '0' else '0'
    return "".join(gene_list)

# 测试
p1 = "0000000000"
p2 = "1111111111"
c1, c2 = crossover(p1, p2)
print(f"父母: {p1}, {p2}")
print(f"孩子 (交叉后): {c1}, {c2}")

m1 = mutate(c1, mutation_rate=0.2) # 高变异率演示
print(f"变异后: {m1}")

3. 群体智能 (Swarm Intelligence)

一只蚂蚁很笨，但一群蚂蚁能找到最短路径；一只鸟乱飞，但鸟群能精准迁徙。这就是涌现 (Emergence)。

3-1.核心理论

粒子群优化 (PSO - Particle Swarm Optimization):

灵感: 鸟群觅食。
策略: 每个粒子（鸟）都在飞，它会参考自己的历史最好位置 (PbestP_{best}Pbest) 和 群体的历史最好位置 (GbestG_{best}Gbest) 来调整速度。
公式:
- w: 惯性权重（保持当前冲劲）。
- : 自我认知（相信自己的经验）。
- : 社会认知（跟风，向大佬学习）。

蚁群算法 (ACO - Ant Colony Optimization):

灵感: 蚂蚁找食物。🐜

策略: 蚂蚁走过的路会留下信息素 (Pheromone)。路越短，往返次数越多，信息素越浓，后面的蚂蚁就越容易跟过来。

AI场景: 专门解决路径规划、网络路由问题。

3-2.实战代码 (PSO 速度更新)

这是 PSO 算法最核心的一行代码。

python 复制代码

import numpy as np

class Particle:
    def __init__(self, bounds):
        self.position = np.random.uniform(bounds[0], bounds[1])
        self.velocity = np.random.uniform(-1, 1)
        self.best_position = self.position
        self.best_score = float('inf')

def update_velocity(particle, global_best_pos, w=0.5, c1=1.5, c2=1.5):
    r1 = np.random.random()
    r2 = np.random.random()
    
    # 核心公式: 惯性 + 自我认知 + 社会认知
    cognitive = c1 * r1 * (particle.best_position - particle.position)
    social = c2 * r2 * (global_best_pos - particle.position)
    
    new_velocity = w * particle.velocity + cognitive + social
    return new_velocity

# 这里的逻辑非常直观：
# 粒子会同时被"自己的最高分"和"全班最高分"拉扯，最终在震荡中收敛到最优解。