数学建模社区-数学中国

标题: 智能优化之粒子群模型Python代码 [打印本页]

作者: 2744557306    时间: 2025-1-1 17:37
标题: 智能优化之粒子群模型Python代码
实现了粒子群优化(Particle Swarm Optimization, PSO)算法,主要用来优化一些特定的函数。具体而言,这里优化的是一个名为“香蕉函数”(通常指的是罗森布鲁克函数,其数学表达式为 \(f(x) = \sum_{i=1}^{n-1} \left(100(x_{i+1} - x_i^2)^2 + (1 - x_i)^2\right)\))。下面将对代码进行详细解读。  u& g& @: I' b& E1 I$ m
/ R3 s3 W/ n8 I  ~; e" f
### 1. 适应度函数 `fit_fun(x)`8 ^: l$ ~, R7 {
* H; B- L, t2 T* X! A- @
```python/ k& b+ o* B6 [- w! K5 Q; y' d
def fit_fun(x):
& B- `" |) V9 w9 \    return sum(100.0 * (x[0][1:] - x[0][:-1] ** 2.0) ** 2.0 + (1 - x[0][:-1]) ** 2.0); i4 r- g3 F+ Z
```
- f3 y' H( R! R  Q; _# H- w- 这是一个用来计算适应度的函数,用于评估给定输入 `x` 的“好坏”程度。对于粒子群优化,通常这个函数的值应该尽可能小。' ]& Y5 m/ k: p- q0 I& g2 n
- 输入 `x` 是一个一维数组,函数计算了罗森布鲁克函数的值。' b3 l* B* w2 B& v8 o2 P6 \8 J( h
8 M, h' X0 H+ H1 U9 j8 a
### 2. 粒子类 `Particle`- _5 I) Z0 T2 C1 b

: D9 k% }: F# }1 j```python
# B6 _% j( d/ G$ Qclass Particle:9 I1 x: x8 o, c3 f9 N5 d
    def __init__(self, x_max, max_vel, dim):
# k0 N/ e7 C+ C2 l; k$ z6 M        self.__pos = np.random.uniform(-x_max, x_max, (1, dim))* r% x: t/ m* x4 ?0 d
        self.__vel = np.random.uniform(-max_vel, max_vel, (1, dim))- m" |( j1 y, N; w# W. j
        self.__bestPos = np.zeros((1, dim))
/ t8 Q! V, J+ f6 A, L2 [& z( y        self.__fitnessValue = fit_fun(self.__pos)
* b1 F' g3 k- s6 I```! }& Q6 X+ c1 h+ d9 [
- 粒子类用于表示粒子的位置、速度和最优位置等信息。  I" P( _7 x* c9 M# e
- 在初始化方法中:# _9 T3 M  ]. |# M1 ~. m
  - `self.__pos`:为粒子初始化一个随机位置。
; F$ l( o+ P- v) R% i5 g  - `self.__vel`:为粒子初始化一个随机的速度。
( G1 a6 T$ m) G! B1 `' m7 d  - `self.__bestPos`:初始化粒子的个体最优位置为全零。
5 _$ _3 W3 O7 @# X  - `self.__fitnessValue`:计算当前粒子位置的适应度值。  n( v" c, G* f

+ Y' E  L7 I9 q1 w, f: {6 _+ X- N. D2 t#### 粒子方法
$ T; \  c! y2 k8 \9 O% R# E/ G; ?
( U3 i6 h' @! L) h7 w! a: n! l- **访问和修改粒子属性**:包括位置、速度和适应度值的 getter 和 setter 函数(如 `get_pos()`, `set_pos(value)` 等)。
( ~% I, I) f5 n) V" y0 ]; s' [
: W, G/ v- ?0 d5 _8 E* P7 v: k### 3. 粒子群优化类 `PSO`
4 R7 C" L! m2 G' `8 H
: U/ V6 i& ~1 Q1 D- R9 W3 s```python2 h' y2 B; F# D% {* R% A: N
class PSO:1 X$ K4 |6 j8 u6 X1 u7 r) E& c: W% T
    def __init__(self, dim, size, iter_num, x_max, max_vel, tol, best_fitness_value=float('Inf'), C1=2, C2=2, W=1):5 [' x4 h4 X3 c. ?) V: q
        self.C1 = C1' X4 i6 O( q# s4 y3 E1 Z
        self.C2 = C2, n, _) y/ _7 R* A( K3 H
        self.W = W
6 X8 |/ O9 R# q& J7 g9 r2 ]) Y        self.dim = dim
% f# r1 S; F+ R9 f3 ]% M" p        self.size = size
; O, E1 `, d- o( o, E& q7 q        self.iter_num = iter_num
" m( C6 i, @. Z, V+ i0 X' a# y+ j        self.x_max = x_max
- r. `& e3 Q: W  `* j; I# ?        self.max_vel = max_vel
" Z1 T) |: j6 Q& g: T3 x        self.tol = tol
+ c; R! U1 D  a2 y0 A5 g        self.best_fitness_value = best_fitness_value
5 L1 x3 e" u1 \5 X' n        self.best_position = np.zeros((1, dim))( V; U5 A# e+ v+ j/ B$ e
        self.fitness_val_list = []
& u9 b! n" X% }) K
$ i8 M- P9 K# O- k3 B3 K! T        # 粒子群初始化$ `+ U4 Z+ M, j6 Y% m& r8 K
        self.Particle_list = [Particle(self.x_max, self.max_vel, self.dim) for i in range(self.size)]
9 P, f. e) N( |# {```, f. i. q& g" B& f! j" S! r
- PSO类负责实现粒子群算法。) l' g8 ~- I  R; S/ d8 W
- 在初始化方法中,定义了以下参数:
* k8 R; Y, Z" K  - `dim`:粒子的维度。) K* V) H$ \; h1 E; w$ |2 R% h  n
  - `size`:粒子的数量。
+ K0 ~; i; c% n- f2 X  - `iter_num`:最大迭代次数。
# q% V& u4 I% ~- S2 _4 `  - `x_max`:粒子位置的最大值。! U  D- @( p. @
  - `max_vel`:粒子的最大速度。
# J5 v# Y/ E% Z4 N+ U% \& f9 y  - `tol`:收敛条件。
! S8 @4 o5 w* M* r# ~8 R  - `C1`, `C2`, `W`:权重因子,控制粒子的个体和社会学习。
* H- H" ]; Z8 ]
0 [$ L7 h. @  n. x# i#### 方法
3 P  T" b1 ^0 e7 T- f7 n
3 O- C# X- u( z1 A3 I& z: c1. **更新速度 `update_vel(self, part)`**
. P' o, r' W3 B2 A! d9 g% W   - 根据当前粒子的位置、最优位置和全局最优位置更新粒子的速度:# u8 F. ?1 R( O& o" v: Q# U
   ```python
- @7 U" _6 Y/ I& S+ l   vel_value = self.W * part.get_vel() + self.C1 * np.random.rand() * (part.get_best_pos() - part.get_pos()) + self.C2 * np.random.rand() * (self.get_bestPosition() - part.get_pos())) U4 Q# L/ R6 w) C* p
   ```
  q% l( u. S+ a2 C
9 G8 y/ x- d( f" y5 s" `- g* g2. **更新位置 `update_pos(self, part)`**, `" m& v2 }2 e9 x$ K6 _# l
   - 更新粒子的位置并计算新的适应度值。如果新的适应度值比当前粒子的最优适应度值更好,就更新最优适应度值和最优位置:) l9 |4 k: O0 R5 r1 T
   ```python
& D2 D6 x6 O" d/ `0 r* b, A! R   pos_value = part.get_pos() + part.get_vel()5 q: S$ `+ i3 e6 M0 {
   ```
3 g) ]/ Z2 M- c/ X
# |# H3 T/ X7 y3. **主迭代方法 `update_ndim(self)`**
9 a7 |+ @! b+ j, [2 X3 o2 z1 |1 k4 Y   - 进行多个迭代,更新每个粒子的速度和位置,同时记录每次迭代的最佳适应度值。
8 f( f' {3 l+ U1 J3 c' L   - 判断是否满足收敛条件,如果发现适应度小于设定的容差 `tol`,则提前终止迭代。
2 E7 K3 }0 Y& K; m! j9 e$ u, l. R, I5 G6 {1 D: b
### 4. 主程序
5 u3 g9 [3 ?. n0 Q: r% A
$ e+ {. \3 R0 P# r- R```python
/ N. E) ^* c* L( _7 R$ P( @% Bif __name__ == '__main__':
1 V; j% E  J5 J. I3 F    pso = PSO(4, 5, 10000, 30, 60, 1e-4, C1=2, C2=2, W=1)
4 U  O1 c6 h1 ]    fit_var_list, best_pos = pso.update_ndim()' Q5 I/ ]7 I. w
    print("最优位置:" + str(best_pos))% K1 e1 b6 F$ E& B/ @
    print("最优解:" + str(fit_var_list[-1]))( ~/ y* c' {; n  {
    plt.plot(range(len(fit_var_list)), fit_var_list, alpha=0.5)
$ M1 E6 E/ V, @) f```2 }' h  ?* M  t+ V0 y
- 创建一个 PSO 对象并设置其参数,例如维度、粒子数量、迭代次数、位置范围等。
7 |3 C2 Q7 u- Q- q; X+ d- 调用 `update_ndim()` 方法运行 PSO 算法,返回每次迭代的适应度值列表和最优位置。% d7 c  ^5 V* F9 J5 ^3 `
- 打印出最优位置并绘制适应度值随迭代的变化图。2 L( `: {1 R- J$ x: ^6 L

, [; j# j- e7 J  G6 [### 总结! h2 X; s5 y1 M; S; ?& q6 ?
2 y$ A; ]; ?. S: C( `
整体代码实现了一个简单的粒子群优化(PSO)算法,用户可以通过调整参数(如粒子数量、速度限制等)来优化特定函数。这个实现涵盖了算法的各个方面,包括粒子的位置和速度的初始化、更新机制、适应度函数的计算等。你可以根据需要更改适应度函数,以便于对其他优化问题进行求解。
& y9 u/ R& T; Z; V8 P
6 D5 L. |2 W5 s+ q- i  b- |
7 X! z; @* q0 L( e6 t6 K; R5 Q' x, F) Y" O1 @8 {

智能优化之粒子群模型Python代码.txt

3.92 KB, 下载次数: 0, 下载积分: 体力 -2 点

售价: 2 点体力  [记录]  [购买]






欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5