数学建模社区-数学中国

标题: 智能优化之粒子群模型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)\))。下面将对代码进行详细解读。
' A9 \5 q, \/ @! H8 U' I
( _) J1 j& J! S9 V: b( a, p% g+ q) |### 1. 适应度函数 `fit_fun(x)`
; l" H# x" M1 ^$ M; R8 I
8 h7 _9 S; t$ V! f( }4 B2 F3 \3 ]3 q```python
: l3 d' o+ Y/ B: W# Udef fit_fun(x):
* _& {5 {/ ?3 B    return sum(100.0 * (x[0][1:] - x[0][:-1] ** 2.0) ** 2.0 + (1 - x[0][:-1]) ** 2.0)9 ]: s0 X: g" M9 x+ T6 H% W
```
& K% M* ?- \0 [& q. R- 这是一个用来计算适应度的函数,用于评估给定输入 `x` 的“好坏”程度。对于粒子群优化,通常这个函数的值应该尽可能小。, B, h9 l" m& [# d  [6 K
- 输入 `x` 是一个一维数组,函数计算了罗森布鲁克函数的值。
* [+ \* p8 }9 @2 v( [
7 |. d4 T: I+ x$ a### 2. 粒子类 `Particle`) W/ l; K: G- Y1 V

  J" A' K3 S& `4 A- P```python
) D, r! g! H6 ?) C0 \  aclass Particle:, X0 V- a, k2 ?+ z6 {
    def __init__(self, x_max, max_vel, dim):
$ [2 G5 i( h4 Y        self.__pos = np.random.uniform(-x_max, x_max, (1, dim)); Z. ]" f* Z7 S& _8 s
        self.__vel = np.random.uniform(-max_vel, max_vel, (1, dim))
4 X# l6 I+ {0 O: v$ k        self.__bestPos = np.zeros((1, dim))
% W$ {, J5 K* m, k9 R- C        self.__fitnessValue = fit_fun(self.__pos)
. i- \! U0 F& W! N5 H: X```
  o# W. R3 Y+ H  ]; a2 F- 粒子类用于表示粒子的位置、速度和最优位置等信息。
' C8 s1 E/ u3 u, w5 ^- 在初始化方法中:
7 l8 d3 ~8 S1 c5 _  - `self.__pos`:为粒子初始化一个随机位置。
1 f6 g; r4 h! O3 G  - `self.__vel`:为粒子初始化一个随机的速度。! s* s% e- ~( V4 c) u
  - `self.__bestPos`:初始化粒子的个体最优位置为全零。
. o' z8 W8 F4 V5 O  - `self.__fitnessValue`:计算当前粒子位置的适应度值。: u* ]: G8 L. X) S$ N3 s/ D

" c0 _3 b% i' U; _* R#### 粒子方法  r1 u3 W( ]% N& D! V
$ B7 E# J# x0 @/ r, `
- **访问和修改粒子属性**:包括位置、速度和适应度值的 getter 和 setter 函数(如 `get_pos()`, `set_pos(value)` 等)。5 e0 H, a$ ^7 u, I0 x

0 D5 ~# m% @8 @0 @8 j### 3. 粒子群优化类 `PSO`; M/ v6 a. {1 F$ c8 {
" s# n) s. d3 N" |& `
```python) t! ^9 d- `3 N2 ~0 q3 X
class PSO:
2 G# \( {6 ^. s0 t6 u# h    def __init__(self, dim, size, iter_num, x_max, max_vel, tol, best_fitness_value=float('Inf'), C1=2, C2=2, W=1):
4 ^: ^" z# Q7 w1 H        self.C1 = C1
  `9 }7 Q" [+ j  J' b. v4 N* `        self.C2 = C2
$ U5 W8 y  v. J& V8 a6 g        self.W = W
. [, ~5 A1 |- ^8 V, J, c% t        self.dim = dim# B3 ?3 U& T& U; g+ ^
        self.size = size# [. o! v: _+ g2 U6 Z2 K( n3 i7 z5 u
        self.iter_num = iter_num2 R& R! ]6 q: c. j4 t  H& k
        self.x_max = x_max
! ]8 S) K0 ?4 V        self.max_vel = max_vel, J, \/ H" ]# g/ S( f: E
        self.tol = tol
, q; D* C! U& m3 s4 l# k5 F        self.best_fitness_value = best_fitness_value
+ p) }7 D; |3 f3 I        self.best_position = np.zeros((1, dim))
' b& q' o. Y+ d1 b! F4 t* ]* y, U        self.fitness_val_list = []" G# Z. S3 _, @! N% {, |( }- S

+ |. N- a% P$ z1 J        # 粒子群初始化( w3 A* X9 R& u6 F  E8 J
        self.Particle_list = [Particle(self.x_max, self.max_vel, self.dim) for i in range(self.size)]
( ]  F8 S. {3 q: g```
" }: L0 j2 z5 v  \0 a" ]; b# v- PSO类负责实现粒子群算法。0 @$ |# B4 ~5 W& }6 {
- 在初始化方法中,定义了以下参数:
5 }; p# H: _. V  - `dim`:粒子的维度。! G1 ?8 P' E2 G/ Q! m
  - `size`:粒子的数量。
; }/ x4 Z. \" K$ |, ~( j; n; @  - `iter_num`:最大迭代次数。: h, h6 Z! q; f5 `3 S6 C
  - `x_max`:粒子位置的最大值。- J1 _  l/ O9 u* X- r
  - `max_vel`:粒子的最大速度。
6 ?, v7 O# `5 s9 k# \  - `tol`:收敛条件。# Q+ I4 t  n- f
  - `C1`, `C2`, `W`:权重因子,控制粒子的个体和社会学习。% [& Q6 W# C! I1 n

& T& u( D% C/ Z# L2 z% c#### 方法+ ]# k6 r# b9 s3 \

3 z9 M& {8 u& y. r3 W7 h1. **更新速度 `update_vel(self, part)`**
1 }0 p7 a; e% ?, o3 _2 Z% v6 m   - 根据当前粒子的位置、最优位置和全局最优位置更新粒子的速度:
9 s. q$ V9 L) [7 `" i; o' c   ```python
3 S' G7 u: g# f7 H' j! 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())- \6 P, V$ J+ L# @% M- F9 R$ n
   ```
' w5 m4 i+ M* v# u; H
$ Q* ~8 `" V  M6 w6 ~2. **更新位置 `update_pos(self, part)`**. {; I" s2 |% J
   - 更新粒子的位置并计算新的适应度值。如果新的适应度值比当前粒子的最优适应度值更好,就更新最优适应度值和最优位置:
1 I$ \6 l' u5 j   ```python
5 r* ~& ]& N4 y; |   pos_value = part.get_pos() + part.get_vel()
, J8 P" \8 e9 N( L* i   ```+ g9 s+ j! w: F' K
. p* Y9 ]% o1 G: _! y. t
3. **主迭代方法 `update_ndim(self)`**
- `: L1 o" P' B# S8 a   - 进行多个迭代,更新每个粒子的速度和位置,同时记录每次迭代的最佳适应度值。0 E3 e5 T( l% N* ^
   - 判断是否满足收敛条件,如果发现适应度小于设定的容差 `tol`,则提前终止迭代。: p6 p9 y: G2 I$ T( q: j% w, a8 l
$ v, M; M' h9 w# k! i1 G
### 4. 主程序
! m6 n( N) }8 H) V/ B. I" A- I1 K$ d4 a3 F, k
```python
$ u5 g% h2 i2 Q; s) |$ S/ zif __name__ == '__main__':
3 F( Y, ~" A% N7 q8 K    pso = PSO(4, 5, 10000, 30, 60, 1e-4, C1=2, C2=2, W=1)
8 m5 p4 A* {7 {( G( y% C- E( z    fit_var_list, best_pos = pso.update_ndim()
% D" \& j, ]/ R* j    print("最优位置:" + str(best_pos))
- v! C# X; p# r4 I. x4 v3 A. B    print("最优解:" + str(fit_var_list[-1]))
/ G& Q1 `9 ?. j    plt.plot(range(len(fit_var_list)), fit_var_list, alpha=0.5)( \* ]( ?  ]; \- g9 V
```$ t; P9 F4 V( X# _5 D3 h
- 创建一个 PSO 对象并设置其参数,例如维度、粒子数量、迭代次数、位置范围等。
' M: a/ s/ z. B% n- 调用 `update_ndim()` 方法运行 PSO 算法,返回每次迭代的适应度值列表和最优位置。$ Z2 x+ R6 }0 w5 t4 ?
- 打印出最优位置并绘制适应度值随迭代的变化图。) z8 o9 Y9 }( F, T9 T9 }2 J

6 D+ z3 I* X. G0 j$ R9 M### 总结6 w& T/ m" k. ?9 p7 t

( o8 K2 Q8 O5 ~1 _1 I/ c+ Q整体代码实现了一个简单的粒子群优化(PSO)算法,用户可以通过调整参数(如粒子数量、速度限制等)来优化特定函数。这个实现涵盖了算法的各个方面,包括粒子的位置和速度的初始化、更新机制、适应度函数的计算等。你可以根据需要更改适应度函数,以便于对其他优化问题进行求解。
# _7 t" w& Z6 M) g4 T+ l- k/ d" v( v: m/ X- d+ q$ b1 I1 C

# A0 r$ Q. D. T- h% g) ~; n4 ]9 h1 l9 _) m( x

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

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

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






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