J'ai écrit un algorithme génétique dans cet article il y a plusieurs fois, mais cette fois j'ai essayé de faire un algorithme d'optimisation fait avec la même idée.
Je vois souvent des poissons et des oiseaux se déplacer en groupe. Même si ces essaims trouvent des ennemis ou de la nourriture, ils effectueront des mouvements optimaux avec des mouvements non perturbés. C'est une méthode pour l'utiliser pour l'optimisation des fonctions.
Les références sont ici Introduction à l'algorithme de calcul évolutif Optimisation des groupes de particules et système non linéaire
Je n'ai rien fait de compliqué et je l'ai implémenté de la manière la plus simple.
functions.py
import random
# min~Faire des nombres au hasard entre max
def randRange(a : float,b : float) -> float:
return a + (b-a)*random.random()
#Générer n particules
def makeParticles(n : int,ranges : dict) -> list:
ls = [{key:0 for key in ranges.keys()} for key in range(n)]
for i in range(n):
for key in ranges.keys():
a,b = ranges[key]
ls[i][key] = randRange(a,b)
return ls
#Ajouter les mêmes éléments de deux dictionnaires
def dictAdd(*dic : dict) -> dict:
ansDic = {}
for key in dic[0].keys():
ansDic[key] = 0
for i in range(len(dic)):
ansDic[key] += dic[i][key]
return ansDic
#Soustrayez les mêmes éléments de deux dictionnaires
def dictDiff(dic1 : dict,dic2 : dict) -> dict:
ansDic = {}
for key in dic1.keys():
ansDic[key] = dic1[key] - dic2[key]
return ansDic
#Produit des mêmes éléments de deux dictionnaires
def dictMul(dic1 : dict, dic2 : dict) -> dict:
ansDic = {}
for key in dic1.keys():
ansDic[key] = dic1[key] * dic2[key]
#Multipliez chaque élément du dict
def dictNumMul(dic : dict,n) -> dict:
ansDic = {}
for key in dic.keys():
ansDic[key] = dic[key] * n
return ansDic
PSO.py
import functions as func
import numpy as np
import copy
"""
time_max Nombre maximum d'itérations
swam_taille Nombre de particules
inertie Coefficient d'inertie
ap Meilleur coefficient d'accélération personnel
ag Meilleur facteur d'accélération mondial
"""
class PSO:
def __init__(self,time_max = 1000,swam_size = 100,
inertia = 0.9,ap = 0.8,ag = 0.8):
self.time_max = time_max
self.swam_size = swam_size
self.inertia = inertia
self.ap = ap
self.ag = ag
self.pBest = [np.inf for i in range(swam_size)]
self.gBest = np.inf
self.gPosi = {}
"""
Passez la fonction que vous souhaitez minimiser à l'argument f de la fonction d'optimisation
dict pour l'argument para
{"Nom de l'argument":[valeur minimum,Valeur maximum]}
Je le passe comme ça.
"""
#Recevez la fonction que vous souhaitez optimiser et ses arguments
def optimize(self,f,para):
self.function = f
self.particleInitialization(para)
self.Update()
for i in range(self.time_max):
self.move()
self.Update()
return self.gPosi,self.gBest
#Initialiser les particules
def particleInitialization(self,ls : dict):
self.particle = func.makeParticles(self.swam_size,ls)
self.pPosi = copy.deepcopy(self.particle)
self.velocity = [{key:0 for key in ls.keys()} for i in range(self.swam_size)]
#Bouge toi
def move(self):
for i in range(self.swam_size):
v0 = func.dictNumMul(self.velocity[i],self.inertia)
v1 = func.dictNumMul(func.dictDiff(self.pPosi[i],self.particle[i]),self.ap*func.randRange(0,1))
v2 = func.dictNumMul(func.dictDiff(self.gPosi,self.particle[i]),self.ag*func.randRange(0,1))
v = func.dictAdd(v0,v1,v2)
self.particle[i] = func.dictAdd(self.particle[i],v)
self.velocity[i] = v
#Mettre à jour le record personnel et le meilleur mondial
def Update(self):
for i in range(self.swam_size):
cost = self.function(**self.particle[i])
if cost < self.pBest[i]:
self.pBest[i] = cost
self.pPosi[i] = copy.deepcopy(self.particle[i])
if cost < self.gBest:
self.gBest = cost
self.gPosi = copy.deepcopy(self.particle[i])
main.py
import PSO
#Définissez la fonction que vous souhaitez minimiser
def f(x,y):
return x**4+4*x**3-8*(x+1)**2-1 + y**4 + x**3 - 5*(y - 2)**2 - 3*x
def main():
pso = PSO.PSO(time_max=1000)
#Premières particules-10000<x<10000,-10000<y<Générer dans la plage de 10000 et minimiser
a,b = pso.optimize(f,{"x":[-10000,10000],"y":[-10000,10000]})
print("Coordonner",a,"valeur minimum",b)
if __name__ == "__main__":
main()
production Coordonnées {'x': -4.412547925687121, 'y': -2.187602966185929} Valeur minimale -196.17514912856427
J'ai pu le minimiser.
[Résultats avec wolframalpha](https://www.wolframalpha.com/input/?i=minimize%5Bx%5E4%2B4x%5E3-8%28x%2B1%29%5E2-1+%2B+ y% 5E4 +% 2B + x% 5E3 + - + 5 *% 28y + - + 2% 29% 5E2 + - + 3 * x% 5D)
C'était tout quand je l'ai téléchargé, mais c'est vraiment terne, donc j'aimerais effectuer une régression logistique en utilisant la méthode d'optimisation des groupes de particules.
Ici, la limite de classification est prédite en minimisant la fonction d'erreur d'entropie croisée par la méthode d'optimisation du groupe de particules.
logistic.py
import functions as func
import math
import PSO
import numpy
#Limite lors de l'étiquetage des nombres aléatoires générés
def f(x,y):
if x + 2 * y < 11:return 1
else:return 0
#Fonction Sigmaid
def sigmoid(x):
if 600 > x > -600:
return 1/(1 + math.exp(-x))
elif x > 0:
return 1
else:
return 0
#Pour renvoyer l'infini quand il est nul
def llog(x):
if x == 0:
return -numpy.inf
return math.log(x)
#Générer des données avec des nombres aléatoires
data = [[func.randRange(0,10),func.randRange(0,10)] for i in range(100)]
label = [f(x,y) for x,y in data]
#Fonction de coût pour minimiser
def loss(w1,w2,b):
ent = 0
for i in range(len(data)):
x = sigmoid(data[i][0]*w1 + data[i][1]*w2 + b)
y = label[i]
ent -= y * llog(x) + (1-y) * llog(1-x)
return ent
def main():
pso = PSO.PSO()
a,b = pso.optimize(loss,{"w1":[-100,100],"w2":[-100,100],"b":[-100,100]})
print(a,b)
#Évaluer si le modèle créé peut classer correctement les données d'entraînement
c = 0
for i in range(100):
n = sigmoid(data[i][0]*a["w1"] + data[i][1]*a["w2"] + a["b"])
ans = 1 if n > 0.5 else 0
if ans == label[i]:
c += 1
print("Précision de classification",c/100)
if __name__ == "__main__":
main()
résultat
{'w1': -5.345994566644921, 'w2': -10.19111400412491, 'b': 56.97834543330356} 2.744570556357321 Précision de classification 1.0
J'ai pu le classer fermement.
Recommended Posts