#0 Ideen für den Wettbewerb
(Auf CSDN teilen, sobald die Wettbewerbsfragen veröffentlicht werden)
https://blog.csdn.net/dc_sinor?type=blog
1 Was ist ein Partikelschwarmalgorithmus?
Particle Swarm Optimization (PSO) ist ein evolutionärer Algorithmus, der durch Nachahmung des Futtersuchverhaltens von Vögeln und Fischen entwickelt wurde. Sein Konzept ist einfach, leicht zu programmieren und zu realisieren, mit hoher Betriebseffizienz und relativ wenigen Parametern, weshalb es weit verbreitet ist. Der Partikelschwarm-Optimierungsalgorithmus wurde 1995 vorgeschlagen und hat eine Geschichte von 24 Jahren (2019).
Die Position jedes Partikels im PSO-Algorithmus stellt eine mögliche Lösung für das gesuchte Problem dar. Die Qualität der Position jedes Partikels im Raum wird durch den Fitnesswert der Position des Partikels im zu suchenden Problem bestimmt. Die Position jedes Partikels in der nächsten Generation wird durch seine Position in dieser Generation und seinen eigenen Geschwindigkeitsvektor bestimmt, und seine Geschwindigkeit bestimmt die Richtung und Entfernung jedes Partikelflugs. Während des Fluges zeichnet das Teilchen die optimale Position P auf, an der es sich befunden hat, und die Gruppe aktualisiert auch die optimale Position G, an der sich die Gruppe befunden hat. Die Fluggeschwindigkeit des Partikels wird durch seine aktuelle Position, die optimale Position, an der sich das Partikel selbst befand, die optimale Position, an der sich die Gruppe befand, und die Geschwindigkeit des Partikels zu diesem Zeitpunkt bestimmt.
2 Geben Sie ein Beispiel
Es gibt zwei Menschen in einem See, die miteinander kommunizieren und den tiefsten Punkt ihrer Position erkennen können. Die Ausgangsposition ist in der Abbildung oben dargestellt. Da die rechte Seite relativ tief ist, wird die Person auf der linken Seite das Boot nach rechts bewegen.
Jetzt ist die linke Seite dunkler, sodass die Person auf der rechten Seite das Boot nach links bewegen wird
Wiederholen Sie den Vorgang so lange, bis sich die beiden Boote schließlich treffen
Man erhält eine lokal optimale Lösung
und jedes Individuum wird als Teilchen dargestellt. Die Position jedes Individuums zu einem bestimmten Zeitpunkt wird als x(t) ausgedrückt und die Richtung wird als v(t) ausgedrückt.
p(t) ist die optimale Lösung des Individuums x zum Zeitpunkt t, g(t) ist die optimale Lösung aller Individuen zum Zeitpunkt t, v(t) ist die Richtung des Individuums zum Zeitpunkt t und x(t) ist die individuelle Position zum Zeitpunkt t
Die nächste Position wird durch x, p und g bestimmt, wie in der Abbildung oben gezeigt
Die Partikel in der Population können die optimale Lösung für das Problem finden, indem sie kontinuierlich aus den historischen Informationen über sich selbst und die Population lernen.
3 ist immer noch ein Beispiel
Die Partikelschwarmoptimierung ist ein Algorithmus, der aus dem Futtersuchverhalten von Vögeln abgeleitet wird. Nun wird unser Protagonist durch einen Vogelschwarm ersetzt.
Das Ziel der kleinen Vögel ist einfach, in dieser Gegend einen Ort mit der meisten Nahrung zu finden, an dem sie sich niederlassen und erholen können. Ihre Suchstrategie an diesem Ort ist wie folgt:
1. Jeder Vogel findet zufällig einen Platz und bewertet die Futtermenge an diesem Ort.
2. Alle Vögel treffen sich gemeinsam und wählen den Ort mit der meisten Nahrung als Kandidatenpunkt G für die Ansiedlung aus.
3. Jeder Vogel blickt auf seine Reise zurück und erinnert sich an den Ort P, an dem er die meiste Nahrung hat.
4. Um einen Platz mit mehr Futter zu finden, fliegt jeder Vogel auf G zu. Ich weiß jedoch nicht, ob das an der Schwierigkeit, eine Wahl zu treffen, oder an der Sehnsucht nach P oder am Misstrauen gegenüber G liegt. Tatsächlich fliegt er in Richtung P , weiß es nicht, ob es eher in Richtung G oder in Richtung P fliegt.
5. Es ist wieder Zeit für das Treffen. Wenn die Vögel beschließen, mit der Suche aufzuhören, wählen sie das aktuelle G, um sich niederzulassen; andernfalls fahren Sie mit 2->3->4->5 fort, um ihren Lebensraum zu finden.
Im Fall der in der Abbildung oben beschriebenen Strategie 4 befindet sich ein Vogel an Punkt A, Punkt G ist der Ort, an dem die Vögel das meiste Futter gefunden haben, und Punkt P ist der Ort, an dem der Vogel das meiste Futter aufgesucht hat. V ist seine aktuelle Fluggeschwindigkeit (Geschwindigkeit ist ein Vektor mit Richtung und Größe), jetzt entscheidet er sich, in Richtung P und G zu fliegen, aber dies ist ein buddhistischer Vogel, wie viel er fliegt, hängt von der Situation ab. Wenn keine Geschwindigkeit V vorhanden ist, sollte es zu Punkt B fliegen. Unter dem Einfluss der Geschwindigkeit V fliegt es aufgrund seiner kombinierten Geschwindigkeit schließlich zu Punkt C, dem nächsten Ziel. Wenn C besser als P ist, ist C das nächste P, und wenn C besser als G ist, ist es das nächste G.
Algorithmusprozess
Algorithmusimplementierung
Hier verwenden die Senioren Python, um die optimale Lösung der Partikelschwarmlösungsfunktion zu demonstrieren
import numpy as np
import matplotlib.pyplot as plt
import random
# 定义“粒子”类
class parti(object):
def __init__(self, v, x):
self.v = v # 粒子当前速度
self.x = x # 粒子当前位置
self.pbest = x # 粒子历史最优位置
class PSO(object):
def __init__(self, interval, tab='min', partisNum=10, iterMax=1000, w=1, c1=2, c2=2):
self.interval = interval # 给定状态空间 - 即待求解空间
self.tab = tab.strip() # 求解最大值还是最小值的标签: 'min' - 最小值；'max' - 最大值
self.iterMax = iterMax # 迭代求解次数
self.w = w # 惯性因子
self.c1, self.c2 = c1, c2 # 学习因子
self.v_max = (interval[1] - interval[0]) * 0.1 # 设置最大迁移速度
#####################################################################
self.partis_list, self.gbest = self.initPartis(partisNum) # 完成粒子群的初始化，并提取群体历史最优位置
self.x_seeds = np.array(list(parti_.x for parti_ in self.partis_list)) # 提取粒子群的种子状态 ###
self.solve() # 完成主体的求解过程
self.display() # 数据可视化展示
def initPartis(self, partisNum):
partis_list = list()
for i in range(partisNum):
v_seed = random.uniform(-self.v_max, self.v_max)
x_seed = random.uniform(*self.interval)
partis_list.append(parti(v_seed, x_seed))
temp = 'find_' + self.tab
if hasattr(self, temp): # 采用反射方法提取对应的函数
gbest = getattr(self, temp)(partis_list)
else:
exit('>>>tab标签传参有误："min"|"max"<<<')
return partis_list, gbest
def solve(self):
for i in range(self.iterMax):
for parti_c in self.partis_list:
f1 = self.func(parti_c.x)
# 更新粒子速度，并限制在最大迁移速度之内
parti_c.v = self.w * parti_c.v + self.c1 * random.random() * (parti_c.pbest - parti_c.x) + self.c2 * random.random() * (self.gbest - parti_c.x)
if parti_c.v > self.v_max: parti_c.v = self.v_max
elif parti_c.v < -self.v_max: parti_c.v = -self.v_max
# 更新粒子位置，并限制在待解空间之内
if self.interval[0] <= parti_c.x + parti_c.v <=self.interval[1]:
parti_c.x = parti_c.x + parti_c.v
else:
parti_c.x = parti_c.x - parti_c.v
f2 = self.func(parti_c.x)
getattr(self, 'deal_'+self.tab)(f1, f2, parti_c) # 更新粒子历史最优位置与群体历史最优位置
def func(self, x): # 状态产生函数 - 即待求解函数
value = np.sin(x**2) * (x**2 - 5*x)
return value
def find_min(self, partis_list): # 按状态函数最小值找到粒子群初始化的历史最优位置
parti = min(partis_list, key=lambda parti: self.func(parti.pbest))
return parti.pbest
def find_max(self, partis_list):
parti = max(partis_list, key=lambda parti: self.func(parti.pbest)) # 按状态函数最大值找到粒子群初始化的历史最优位置
return parti.pbest
def deal_min(self, f1, f2, parti_):
if f2 < f1: # 更新粒子历史最优位置
parti_.pbest = parti_.x
if f2 < self.func(self.gbest):
self.gbest = parti_.x # 更新群体历史最优位置
def deal_max(self, f1, f2, parti_):
if f2 > f1: # 更新粒子历史最优位置
parti_.pbest = parti_.x
if f2 > self.func(self.gbest):
self.gbest = parti_.x # 更新群体历史最优位置
def display(self):
print('solution: {}'.format(self.gbest))
plt.figure(figsize=(8, 4))
x = np.linspace(self.interval[0], self.interval[1], 300)
y = self.func(x)
plt.plot(x, y, 'g-', label='function')
plt.plot(self.x_seeds, self.func(self.x_seeds), 'b.', label='seeds')
plt.plot(self.gbest, self.func(self.gbest), 'r*', label='solution')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('solution = {}'.format(self.gbest))
plt.legend()
plt.savefig('PSO.png', dpi=500)
plt.show()
plt.close()
if __name__ == '__main__':
PSO([-9, 5], 'max')
Wirkung
