Création d'un algorithme génétique simple et efficace pour un réseau de neurones avec Python et NumPy

Il s'agit du premier article du cours sur les algorithmes d'évolution en ML.

Un algorithme génétique est nécessaire lorsque vous connaissez les paramètres de votre réseau neuronal, mais que vous ne savez pas quelle devrait être la sortie, par exemple, cet algorithme peut être utilisé pour jouer à Google Dinosaur ou Flappy Bird, car là vous ne savez pas quel devrait être le résultat, mais vous avez la possibilité de trier les options les plus viables, par exemple par temps, c'est ce qu'on appelle les fonctions de fitness.

Je n'ai jamais été en mesure de trouver un tel algorithme qui fonctionnerait, serait simple et utilisable, alors j'ai commencé à créer mon propre algorithme génétique léger, simple et parfaitement fonctionnel.

Mon objectif n’est pas de faire traîner la rédaction de cet article, et de torturer les lecteurs avec sa longueur, alors passons directement au code. Comme déjà mentionné, le code est simple, il n'est donc pas nécessaire de le décrire en grande partie dans des essais entiers.

Nous devons d'abord importer les modules :

import numpy as np
import random

Ensuite, nous ajoutons Dataset et les réponses, mais pas pour utiliser l'algorithme de rétropropagation, mais simplement pour compter le nombre de réponses correctes. Vous pourrez ensuite le tester sur d'autres variantes, qui sont désormais commentées

x = np.array([[1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 1, 1], [1, 1, 1]])
y = np.array([[0],[1],[1], [0], [0], [0], [0], [1], [1]])

#x = np.array([[0, 1, 1], [0, 0, 1], [1, 0, 1], [0, 1, 0], [1, 0, 0], [1, 1, 0], [0, 0, 0], [1, 1, 0], [1, 1, 1]])
#y = np.array([[1],[0], [0], [1], [0], [1], [0], [1], [1]])

#x = np.array([[1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 0], [1, 0, 0], [0, 0, 0], [1, 1, 0], [0, 1, 1], [1, 1, 1]])
#y = np.array([[1],[0],[1], [0], [1], [0], [1], [0], [1]])

Ajoutez des listes et des fonctions d'activation. La signification des listes deviendra claire plus tard. La première fonction d'activation est le sigmoïde et la seconde est le seuil.

listNet = []
NewNet = []
goodNET = []
GoodNet0 = []
GoodNet1 = []
GoodNet2 = []
GoodNet3 = []
GoodNet4 = []
GoodNet5 = []
GoodNet6 = []
good = 0
epoch = 0

good = 0
epoch = 0

def sigmoid(x):
    return 1/(1 + np.exp(-x)) 
def finfunc(x):
    if x[0] >= 0.5:
        x[0] = 1
        return x[0]

    else:
        x[0] = 0
        return x[0]

Ensuite, nous devrons créer deux classes, la première est nécessaire pour créer la population initiale, et la seconde pour toutes les suivantes, puisque la première fois nous devrons créer des poids au hasard, puis seulement croiser et les muter. La fonction init() est utilisée pour créer ou ajouter des poids, prédire() est nécessaire pour l'algorithme lui-même et pour calculer les meilleures options, et la fonction Fredic() est différente en ce sens qu'elle renvoie la réponse et la fonction fitness pour afficher les nombres. sur l'écran et voir les étapes de formation. Au niveau de la couche de sortie, la fonction sigmoïde est d'abord utilisée pour rapprocher la réponse de l'une des options, et ensuite seulement la fonction seuil.

class Network():
    def __init__(self):
        self.H1 = np.random.randn(3, 6)
        self.O1 = np.random.randn(6, 1)

    def predict(self, x, y):
        t1 = x @ self.H1
        t1 = sigmoid(t1)
        t2 = t1 @ self.O1
        t2 = sigmoid(t2)
        t2 = finfunc(t2)
        if t2 == y[0]:
            global good
            good += 1

    def Fpredict(self, x, y):
        t1 = x @ self.H1
        t1 = sigmoid(t1)
        t2 = t1 @ self.O1
        t2 = sigmoid(t2)
        t2 = finfunc(t2)
        if t2 == y[0]:
            global good
            good += 1
        return t2, good
class Network1():
    def __init__(self, H1, O1):
        self.H1 = H1
        self.O1 = O1


    def predict(self, x, y):
        t1 = x @ self.H1
        t1 = sigmoid(t1)
        t2 = t1 @ self.O1
        t2 = sigmoid(t2)
        t2 = finfunc(t2)
        if t2 == y[0]:
            global good
            good += 1
    def Fpredict(self, x, y):
        t1 = x @ self.H1
        t1 = sigmoid(t1)
        t2 = t1 @ self.O1
        t2 = sigmoid(t2)
        t2 = finfunc(t2)
        if t2 == y[0]:
            global good
            good += 1
        return t2, good

On sort les premières réponses et la variable good, qui est ici la fonction fitness, puis on la réinitialise pour le prochain réseau de neurones, l'impression 'wait0' (vous pouvez écrire ce que vous voulez ici) est nécessaire pour ne pas ne savez pas où commencent les réponses des différents réseaux de neurones.

import numpy as np
import random

Le premier cycle passe, ici et dans tous les cycles suivants, nous ne posons que six questions pour vérifier dans quelle mesure il s'acquittera de la tâche qu'il n'a pas accomplie, c'est-à-dire que nous vérifions son bachotage, et cela arrive parfois. Et maintenant, entrons plus en détail : en fonction du nombre de réponses auxquelles il a répondu correctement, nous l'attribuons à l'une des classes, si un grand nombre sont corrects, alors nous devons prendre en charge un tel réseau de neurones et augmenter son nombre, de sorte qu'avec le mutation ultérieure, il y en aura plus de plus intelligents, pour comprendre cela, vous pouvez imaginer que pour 100 personnes il y a un génie, mais ce n'est pas suffisant pour tout le monde, et cela signifie que son génie disparaîtra dans les générations suivantes, cela signifie que soit le réseau de neurones apprendra très lentement, ou n'existera pas du tout, pour éviter cela, on augmente le nombre de réseaux de neurones avec un grand nombre de réponses correctes dans le cycle. A la fin, on vide la liste listNet principale, on lui attribue de nouvelles valeurs des listes GoodNet dans l'ordre du meilleur au pire, on fait une coupe pour les 100 meilleurs individus, pour la mutation ultérieure.

x = np.array([[1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 1, 1], [1, 1, 1]])
y = np.array([[0],[1],[1], [0], [0], [0], [0], [1], [1]])

#x = np.array([[0, 1, 1], [0, 0, 1], [1, 0, 1], [0, 1, 0], [1, 0, 0], [1, 1, 0], [0, 0, 0], [1, 1, 0], [1, 1, 1]])
#y = np.array([[1],[0], [0], [1], [0], [1], [0], [1], [1]])

#x = np.array([[1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 0], [1, 0, 0], [0, 0, 0], [1, 1, 0], [0, 1, 1], [1, 1, 1]])
#y = np.array([[1],[0],[1], [0], [1], [0], [1], [0], [1]])

Le croisement et la mutation en lui-même : on prend une partie du premier parent, la seconde du deuxième, on mute et on obtient un enfant dans la liste NewNet, donc 1000 fois.

listNet = []
NewNet = []
goodNET = []
GoodNet0 = []
GoodNet1 = []
GoodNet2 = []
GoodNet3 = []
GoodNet4 = []
GoodNet5 = []
GoodNet6 = []
good = 0
epoch = 0

good = 0
epoch = 0

def sigmoid(x):
    return 1/(1 + np.exp(-x)) 
def finfunc(x):
    if x[0] >= 0.5:
        x[0] = 1
        return x[0]

    else:
        x[0] = 0
        return x[0]

À partir de la partie précédente du code, nous utilisons Network1(), puisque nous croisons et mutéons maintenant, mais ne créons pas au hasard. Il faut donc répéter 1000 fois (c'est un hyperparamètre, donc vous pouvez choisir vous-même le nombre d'époques, 15 me suffisaient), on montre les réponses sur la première époque et la 1000ème est la version finale (si vous en avez, par exemple, 20, puis précisez 20). Ici le code est répété, donc je ne le décrirai pas, tout y est très clair.

import numpy as np
import random

C'est tout, le modèle que le réseau de neurones doit trouver, c'est de quel numéro (premier, deuxième, troisième) dépend la version finale et ignorer le reste. Vous pouvez faire, par exemple, des opérations logiques (XOR, NOT, AND ...), seulement dans ce cas dans la classe réseau changer les données d'entrée par deux, j'ai également suivi la règle les neurones de la couche cachée sont égaux à l'entrée données multipliées par deux, cela a fonctionné, mais vous pouvez essayer vos options, il est également très important de fournir au réseau de neurones le même nombre de certaines réponses et d'autres réponses, afin que le nombre de réponses correctes, par exemple "a", serait égal à "b", sinon le réseau de neurones répondra à toutes les réponses de la même manière, c'est-à-dire que s'il y a plus de a, alors il répondra à tout et rien n'en sortira, donnez-lui également des options complètement différentes dans l'échantillon d'entraînement afin qu'il comprenne le modèle, par exemple, si vous faites un bloc XOR, alors vous devez ajouter une option avec deux uns, mais dans le cas d'opérations logiques, vous devrez donner toutes les options, car il y en a trop peu et il ne comprendra rien.
C'est ça!!! Article suivant (à lire absolument !) : Bientôt…
Code : https://github.com/LanskoyKirill/GenNumPy.git

Mon site (il est peut-être en cours de refonte) : selfrobotics.space

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!