[PYTHON] Versuchen Sie, das Problem der Funktionsminimierung mithilfe der Partikelgruppenoptimierung zu lösen

Partikelgruppenoptimierung

Die Partikelschwarmoptimierung (PSO) ist eine Art von Gruppenintelligenz und wird für Kombinationsoptimierungsprobleme als Lösungssuchmethode verwendet. Es ist ein Fluss, mit der Suche fortzufahren, indem die Aktualisierung von zwei Informationen, der Geschwindigkeit und Position des Partikels, wiederholt wird. Die folgende Abbildung zeigt die Partikelgruppenoptimierung.

Algorithmus

Der Algorithmus zur Partikelgruppenoptimierung ist wie folgt.

Erneuerungsformel

Die Geschwindigkeit und Position der Partikel werden durch die folgende Aktualisierungsformel aktualisiert. Einfach ausgedrückt repräsentiert die Geschwindigkeit die Richtung, in die sich das Partikel entwickelt, und die Position repräsentiert die Parameter des Partikels selbst.

Experiment

Lösen wir das Optimierungsproblem. Diesmal

x^2 + y^2

Lösen wir das Minimierungsproblem. Daher ist (x, y) = (0,0) die optimale Lösung. Der verwendete Code lautet wie folgt.

# -*- coding: utf-8 -*-
import numpy as np
import random

#Bewertungsfunktion
def evaluate(particle):
    z = 0
    for i in range(len(particle)):
        z += particle[i] ** 2
    return z

#Positionsaktualisierung
def update_position(particle, velocity):
    new_particle = particle + velocity
    return new_particle

#Geschwindigkeitsaktualisierung
def update_velocity(particle, velocity, pbest, gbest, w=0.5, max=0.15):
    new_velocity = np.array([0.0 for i in range(len(particle))])
    #new_velocity = [0.0 for i in range(len(particle))]
    r1 = random.uniform(0, max)
    r2 = random.uniform(0, max)
    for i in range(len(particle)):
        new_velocity[i] = (w * float(velocity[i]) + r1 * (float(pbest[i]) - float(particle[i])) + r2 * (float(gbest[0]) - float(particle[i])))

    return new_velocity

def main():
    N = 100 #Anzahl der Partikel
    length = 2  #Anzahl der Dimensionen
    para_max = 100  #Maximalwert des Parameters
    #Initialisierung der Partikelposition
    ps = [[random.uniform(-para_max, para_max) for j in range(length)] for i in range(N)]
    vs = [[0.0 for j in range(length)] for i in range(N)]
    #Persönlicher Rekord
    personal_best_position = ps
    #Persönliche Bestbewertung
    personal_best_scores = [evaluate(p) for p in ps]
    #Index des Partikels mit dem niedrigsten Bewertungswert
    best_particle = np.argmin(personal_best_scores)
    #Weltweit am besten
    global_best_position = personal_best_position[best_particle]

    generation = 30 #Maximale Anzahl von Generationen
    #Schleife für mehrere Generationen
    for t in range(generation):
        file = open("data/pso/pso" + str(t+1) + ".txt", "w")
        #Schleife für ein paar Minuten
        for n in range(N):
            #Datei schreiben
            file.write(str(ps[n][0]) + " " + str(ps[n][1]) + "\n")
            #Aktualisierung der Partikelgeschwindigkeit
            vs[n] = update_velocity(ps[n], vs[n], personal_best_position[n], global_best_position)
            #Partikelposition aktualisieren
            ps[n] = update_position(ps[n], vs[n])

            #Berechnen Sie den Bewertungswert und finden Sie die persönliche Bestleistung
            score = evaluate(ps[n])
            if score < personal_best_scores[n]:
                personal_best_scores[n] = score
                personal_best_position[n] = ps[n]
        #Aktualisieren Sie die weltweit besten
        best_particle = np.argmin(personal_best_scores)
        global_best_position = personal_best_position[best_particle]
        file.close()

    print(global_best_position)
    print(min(personal_best_scores))

if __name__ == '__main__':
    main()

Versuchsergebnis

Personen der 1., 10., 20. und 30. Generation sind farblich gekennzeichnet und in der Abbildung dargestellt. Sie können sehen, dass die Partikel im Verlauf der Generierung gegen (0,0) konvergieren.