Laissez-vous comprendre brièvement le contenu de la création de modèles de réseaux neuronaux en python

Le contenu de cet article est de vous donner une brève compréhension de la façon de créer un modèle de réseau neuronal en python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Résumé : Curieux de savoir comment fonctionnent les réseaux de neurones ? Essayez-le. La meilleure façon de comprendre le fonctionnement des réseaux de neurones est de créer vous-même un réseau de neurones simple.

Le réseau de neurones (NN), également connu sous le nom de réseau de neurones artificiels (ANN), est un sous-ensemble d'algorithmes d'apprentissage dans le domaine de l'apprentissage automatique, empruntant vaguement le concept de réseaux de neurones biologiques. À l’heure actuelle, les réseaux de neurones sont largement utilisés dans des domaines tels que la vision par ordinateur et le traitement du langage naturel. Andrey Bulezyuk, un expert allemand en apprentissage automatique, a déclaré : « Les réseaux de neurones révolutionnent l'apprentissage automatique car ils peuvent simuler efficacement des abstractions complexes dans diverses disciplines et industries sans grande implication humaine.
En général, les réseaux de neurones artificiels comprennent essentiellement. les composants suivants :

• couche d'entrée qui reçoit des données et transmet des données ;

• couche cachée ; 🎜>Couche de sortie ;

• Le poids entre les couches

• La fonction d'activation utilisée par chaque couche cachée

• Dans ce tutoriel, une simple fonction d'activation sigmoïde est utilisée, mais veuillez noter que dans les réseaux de neurones profonds Dans les modèles de réseau, la fonction d'activation sigmoïde n'est généralement pas le premier choix car elle est sujette à la dispersion du gradient.

De plus, il existe plusieurs types différents de réseaux de neurones artificiels, tels que les réseaux de neurones à action directe, les réseaux de neurones convolutifs et les réseaux de neurones récurrents. Cet article prendra comme exemple un simple réseau neuronal à réaction ou perception. Ce type de réseau neuronal artificiel transfère les données directement de l'avant vers l'arrière, ce que l'on appelle le processus de propagation vers l'avant.

La formation des neurones à réaction nécessite généralement un algorithme de rétropropagation, qui nécessite de fournir au réseau les ensembles d'entrées et de sorties correspondants. Lorsque les données d'entrée sont transmises à un neurone, elles sont traitées en conséquence et la sortie résultante est transmise à la couche suivante.

La figure suivante montre simplement une structure de réseau neuronal :

De plus, la meilleure façon de comprendre le fonctionnement d'un réseau neuronal est d'apprendre comment pour en créer un à partir de zéro en utilisant n'importe quelle boîte à outils. Dans cet article, nous montrerons comment créer un réseau de neurones simple à l'aide de Python. Problème

Le tableau ci-dessous montre le problème que nous allons résoudre :

Nous entraînerons le réseau neuronal afin qu'il puisse prédire la valeur de sortie correcte lorsqu'on lui donne un nouvel ensemble de données .

Comme vous pouvez le voir dans le tableau, la valeur de sortie est toujours égale à la première valeur de la section d'entrée. Par conséquent, nous pouvons nous attendre à ce que la valeur de sortie (?) de la nouvelle situation soit 1.

Voyons si nous pouvons obtenir le même résultat en utilisant du code Python.

Créer une classe de réseau neuronal|Classe NeuralNetwork

Nous allons créer une classe NeuralNetwork en Python pour entraîner les neurones à fournir des prédictions précises. Cette classe contient également d'autres fonctions d'assistance. Nous n'utiliserons pas la bibliothèque de réseaux de neurones pour créer cet exemple simple de réseau de neurones, mais importerons la bibliothèque de base Numpy pour faciliter le calcul.

La bibliothèque Numpy est une bibliothèque de base pour le traitement des données. Elle dispose des quatre méthodes de calcul importantes suivantes :

EXP - utilisée pour générer l'exposant naturel ;

• tableau - utilisé pour générer des matrices;

• point - utilisé pour la multiplication matricielle

• aléatoire - utilisé pour générer des nombres aléatoires ;

• Application de la fonction Sigmoïde
  Nous utiliserons la fonction Sigmoïde, qui dessine une courbe en forme de "S", Elle sert de fonction d'activation de le réseau de neurones créé dans cet article.

Cette fonction peut mapper n'importe quelle valeur entre 0 et 1 et nous aide à normaliser la somme pondérée de l'entrée. Après cela, nous créerons la dérivée de la fonction sigmoïde pour aider à calculer les ajustements de base des poids.

La sortie de la fonction Sigmoïde peut être utilisée pour générer sa dérivée. Par exemple, si la variable de sortie est "x", alors sa dérivée sera x *(1-x).

Formation du modèle

La formation du modèle désigne l'étape où nous apprendrons au réseau neuronal à faire des prédictions précises. Chaque entrée a un poids - positif ou négatif, ce qui signifie que les entrées avec des poids positifs ou négatifs importants auront un impact plus important sur le résultat obtenu.

Notez que lorsque le modèle est initialement entraîné, chaque poids est initialisé avec un nombre aléatoire.

Voici le processus d'entraînement dans l'exemple de problème de réseau neuronal construit dans cet article :

1 Obtenez les entrées de l'ensemble de données d'entraînement, effectuez quelques ajustements en fonction de leurs poids. , et calcule le réseau neuronal via La méthode de sortie est utilisée pour transmettre couche par couche

2. Calculez le taux d'erreur de rétropropagation. Dans ce cas, il s'agit de l'erreur entre la sortie prédite du neurone et la sortie attendue de l'ensemble de données d'entraînement

3. En fonction de la plage d'erreur résultante, utilisez l'erreur pondérée ; dérivé La formule effectue quelques petits ajustements de poids

4. Répétez ce processus 15 000 fois, et à chaque itération, l'ensemble de l'entraînement est traité simultanément

Ici, nous utilisons la fonction ".T" pour biaiser la matrice. Par conséquent, les nombres seront stockés de cette façon :

À terme, les poids des neurones seront optimisés pour les données d'entraînement fournies. Par conséquent, si le résultat du réseau neuronal est cohérent avec le résultat attendu, cela signifie que la formation est terminée et que des prédictions précises peuvent être faites. C'est la méthode de rétropropagation.

Encapsulation

Enfin, après avoir initialisé la classe NeuralNetwork et exécuté l'intégralité du programme, voici le code complet expliquant comment créer un réseau neuronal dans un projet Python :

import numpy as np

class NeuralNetwork():
    
    def __init__(self):
        # 设置随机数种子
        np.random.seed(1)
        
        # 将权重转化为一个3x1的矩阵，其值分布为-1~1，并且均值为0
        self.synaptic_weights = 2 * np.random.random((3, 1)) - 1

    def sigmoid(self, x):
        # 应用sigmoid激活函数
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        #计算Sigmoid函数的偏导数
        return x * (1 - x)

    def train(self, training_inputs, training_outputs, training_iterations):
        
        # 训练模型
        for iteration in range(training_iterations):
            # 得到输出
            output = self.think(training_inputs)

            # 计算误差
            error = training_outputs - output
            
            # 微调权重
            adjustments = np.dot(training_inputs.T, error * self.sigmoid_derivative(output))

            self.synaptic_weights += adjustments

    def think(self, inputs):
        # 输入通过网络得到输出   
        # 转化为浮点型数据类型
        
        inputs = inputs.astype(float)
        output = self.sigmoid(np.dot(inputs, self.synaptic_weights))
        return output


if __name__ == "__main__":

    # 初始化神经类
    neural_network = NeuralNetwork()

    print("Beginning Randomly Generated Weights: ")
    print(neural_network.synaptic_weights)

    #训练数据
    training_inputs = np.array([[0,0,1],
                                [1,1,1],
                                [1,0,1],
                                [0,1,1]])

    training_outputs = np.array([[0,1,1,0]]).T

    # 开始训练
    neural_network.train(training_inputs, training_outputs, 15000)

    print("Ending Weights After Training: ")
    print(neural_network.synaptic_weights)

    user_input_one = str(input("User Input One: "))
    user_input_two = str(input("User Input Two: "))
    user_input_three = str(input("User Input Three: "))
    
    print("Considering New Situation: ", user_input_one, user_input_two, user_input_three)
    print("New Output data: ")
    print(neural_network.think(np.array([user_input_one, user_input_two, user_input_three])))
    print("Wow, we did it!")

Ce qui suit est la sortie d'exécution produite après le code :

Ci-dessus se trouve un simple réseau neuronal que nous avons réussi à créer. Tout d’abord, le réseau neuronal commence à s’attribuer des poids aléatoires, puis s’entraîne à l’aide d’exemples d’entraînement.

Donc, si une nouvelle entrée d'échantillon [1,0,0] se produit, sa valeur de sortie est de 0,9999584. La bonne réponse attendue est 1. On peut dire que les deux sont très proches étant donné que la fonction sigmoïde est une fonction non linéaire, cette erreur est acceptable.

De plus, cet article n'utilise qu'une seule couche de réseau neuronal pour effectuer des tâches simples. Que se passerait-il si nous rassemblions des milliers de ces réseaux de neurones artificiels ? Pouvons-nous imiter la pensée humaine à 100 % ? La réponse est oui, mais c’est actuellement difficile à mettre en œuvre. On peut seulement dire que c’est très similaire. Les lecteurs intéressés peuvent lire des documents liés à l'apprentissage profond.

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!