python编写PSO算法

关键在于赋值的关系:
浅赋值:对原来的引用
深度赋值:才是对值影响

#! /user/bin/env python
#encoding=utf-8
__author__ = 'chw'
import time
import numpy as np
import copy
import matplotlib.pyplot as plt
start=time.time()
c1=2
c2=2
PopMax=100
Vmax=PopMax/10
SizePop=20
D=2
Maxgen=200
Wmax=0.9
Wmin=0.4
pop=np.random.rand(SizePop,D)*2*PopMax-PopMax
v=np.random.rand(SizePop,D)*Vmax*2-Vmax

def fun(x1,x2):
    return x1**2+x2**2

fitness=np.zeros((SizePop,1),dtype=float)
for i in xrange(SizePop):
    fitness[i]=fun(pop[i,0],pop[i,1])
bestfitness=max(fitness)
for i in xrange(SizePop):
    if fitness[i]==bestfitness:
        zbest=pop[i,:]
        break
gbest=pop
fitnessgbest=fitness
fitnesszbest=bestfitness
# yy=np.zeros((Maxgen,1),dtype=float)
yy=np.random.rand(Maxgen,1)
x=np.arange(Maxgen)
for i in xrange(Maxgen):
    if i==0:
        w=Wmax
    else:
        w=Wmax-i*0.5/Maxgen
    for j in xrange(SizePop):
        v[j,:]=w*v[j,:]+c1*np.random.rand()*(gbest[j,:]-pop[j,:])+c2*np.random.rand()*(zbest-pop[j,:])
        pop[j,:]=pop[j,:]+v[j,:]
        for t in xrange(D):
            if pop[j,t]>PopMax:
                pop[j,t]=PopMax
            if pop[j,t]<-PopMax:
                pop[j,t]=-PopMax
            if v[j,t]>Vmax:
                v[j,t]=Vmax
            if v[j,t]<-Vmax:
                v[j,t]=-Vmax
        fitness[j]=fun(pop[j,0],pop[j,1])
    for j in xrange(SizePop):
        if fitness[j]<fitnessgbest[j]:
            gbest[j,:]=copy.deepcopy(pop[j,:])
            fitnessgbest[j]=copy.deepcopy(fitness[j])
    for j in xrange(SizePop):
        if fitnessgbest[j]<fitnesszbest:
            zbest=copy.deepcopy(gbest[j,:])
            fitnesszbest=copy.deepcopy(fitnessgbest[j])
    yy[i]=copy.deepcopy(fitnesszbest)
print zbest
print fitnesszbest
plt.figure()
plt.plot(x,yy)
plt.show()
print time.time()-start
# s1=[0,1,2]
# s2=[2,3,4]
# plt.figure()
# plt.plot(s1,s2)
# plt.show()

这里写图片描述
参考:http://blog.csdn.net/just_do_it_123/article/details/50927348
http://www.jb51.net/article/61902.htm

  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
### 回答1: 粒子群算法(Particle Swarm Optimization, PSO)是一种基于群体智能的优化算法。它通过模拟粒子在多维空间中的运动,以找到全局最优解。 下面是一个使用Python编写的粒子群算法的示例: ``` import random import numpy as np def fitness_function(position): # 这里是适应度函数,根据位置计算适应度值 # 可以替换为任意其他函数 return sum(position**2) def update_velocity(particle, best_particle, velocity, c1, c2): r1 = random.uniform(0, c1) r2 = random.uniform(0, c2) velocity = 0.8 * velocity + r1 * (best_particle - particle) + r2 * (np.array([random.uniform(-5, 5) for i in range(len(particle))]) - particle) return velocity def update_position(particle, velocity): particle = particle + velocity return particle def pso(n_particles, dimensions, iterations): # 初始化粒子的位置和速度 particles = [np.array([random.uniform(-5, 5) for i in range(dimensions)]) for j in range(n_particles)] velocities = [np.array([0 for i in range(dimensions)]) for j in range(n_particles)] best_particles = particles[:] best_fitnesses = [fitness_function(particle) for particle in particles] for i in range(iterations): for j in range(n_particles): fitness = fitness_function(particles[j]) if fitness < best_fitnesses[j]: best_particles[j] = particles[j] best_fitnesses[j] = fitness global_best = min(best_fitnesses) global_best_particle = best_particles[best_fitnesses.index(global_best)] for j in range(n_particles): velocities[j] = update_velocity(particles[j], global_best_particle, velocities[j], c1=2, c2=2) particles[j] = update_position(particles[j], velocities[j]) return global_best, global_best_particle result = pso(n_particles=100, dimensions=2, iterations= ### 回答2: 粒子群算法(Particle Swarm Optimization,PSO)是一种优化算法,灵感来源于群体智能中鸟类群体的行为。下面是一个用Python编写的简单粒子群算法示例: 1. 首先,我们定义粒子的类,包括粒子的位置、速度和适应度。 ```python class Particle: def __init__(self, position, velocity): self.position = position self.velocity = velocity self.fitness = self.evaluate_fitness() def evaluate_fitness(self): # 计算粒子的适应度值,根据具体问题而定 pass ``` 2. 接下来,我们初始化粒子群,包括粒子的数量、位置和速度的范围。 ```python num_particles = 20 position_range = (-10, 10) velocity_range = (-1, 1) # 初始化粒子群 particles = [] for _ in range(num_particles): position = [random.uniform(position_range[0], position_range[1]) for _ in range(num_dimensions)] velocity = [random.uniform(velocity_range[0], velocity_range[1]) for _ in range(num_dimensions)] particles.append(Particle(position, velocity)) ``` 3. 然后,我们定义粒子群的更新规则,包括位置和速度的更新。 ```python c1 = 2.0 # 学习因子1,表示个体经验 c2 = 2.0 # 学习因子2,表示群体经验 # 更新粒子群 for particle in particles: new_velocity = [] new_position = [] for i in range(num_dimensions): # 更新速度 velocity = particle.velocity[i] new_velocity.append(velocity + c1 * random.random() * (best_position[i] - particle.position[i]) + c2 * random.random() * (global_best_position[i] - particle.position[i])) # 更新位置 position = particle.position[i] new_position.append(position + new_velocity[i]) particle.velocity = new_velocity particle.position = new_position particle.fitness = particle.evaluate_fitness() ``` 4. 最后,我们找出最优解,即适应度最大的粒子。 ```python # 找出适应度最大的粒子 best_particle = max(particles, key=lambda x: x.fitness) best_position = best_particle.position ``` 这只是一个简单的粒子群算法示例,实际应用中可能需要根据具体问题进行适当的修改和扩展。希望对你有所帮助!
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值