[PYTHON] Essayez de résoudre le problème de minimisation des fonctions en utilisant l'optimisation des groupes de particules

Optimisation des groupes de particules

L'optimisation des essaims de particules (PSO) est un type d'intelligence de groupe et est utilisée pour les problèmes d'optimisation combinée comme méthode de recherche de solution. C'est un flux pour procéder à la recherche en répétant la mise à jour de deux informations, la vitesse et la position de la particule. La figure ci-dessous est une image de l'optimisation des groupes de particules.

algorithme

L'algorithme d'optimisation des groupes de particules est le suivant.

Formule de renouvellement

La vitesse et la position des particules sont mises à jour par la formule de mise à jour suivante. En termes simples, la vitesse représente la direction dans laquelle la particule évolue et la position représente les paramètres de la particule elle-même.

Expérience

Résolvons réellement le problème d'optimisation. Cette fois

x^2 + y^2

Résolvons le problème de minimisation. Par conséquent, (x, y) = (0,0) est la solution optimale. Le code utilisé est le suivant.

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

#Fonction d'évaluation
def evaluate(particle):
    z = 0
    for i in range(len(particle)):
        z += particle[i] ** 2
    return z

#Mise à jour de la position
def update_position(particle, velocity):
    new_particle = particle + velocity
    return new_particle

#Mise à jour de la vitesse
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 #Nombre de particules
    length = 2  #Nombre de dimensions
    para_max = 100  #Valeur maximale du paramètre
    #Initialisation de la position des particules
    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)]
    #Record personnel
    personal_best_position = ps
    #Meilleure note personnelle
    personal_best_scores = [evaluate(p) for p in ps]
    #Index de la particule avec la valeur d'évaluation la plus basse
    best_particle = np.argmin(personal_best_scores)
    #Meilleur mondial
    global_best_position = personal_best_position[best_particle]

    generation = 30 #Nombre maximum de générations
    #Boucle depuis plusieurs générations
    for t in range(generation):
        file = open("data/pso/pso" + str(t+1) + ".txt", "w")
        #Boucle pendant quelques minutes
        for n in range(N):
            #Écriture de fichier
            file.write(str(ps[n][0]) + " " + str(ps[n][1]) + "\n")
            #Mise à jour de la vitesse des particules
            vs[n] = update_velocity(ps[n], vs[n], personal_best_position[n], global_best_position)
            #Mettre à jour la position des particules
            ps[n] = update_position(ps[n], vs[n])

            #Calculez la valeur d'évaluation et trouvez le record personnel
            score = evaluate(ps[n])
            if score < personal_best_scores[n]:
                personal_best_scores[n] = score
                personal_best_position[n] = ps[n]
        #Mettez à jour le meilleur du monde
        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()

Résultat expérimental

Les individus des générations 1, 10, 20 et 30 sont codés par couleur et représentés sur la figure. Vous pouvez voir que les particules convergent vers (0,0) à mesure que la génération progresse.