Comprendre et mettre en œuvre un réseau de neurones XOR simple

Cet article présente les bases des réseaux de neurones et prend la mise en œuvre d'un réseau de neurones XOR simple comme exemple pour expliquer en détail le principe de fonctionnement et les concepts clés des réseaux de neurones. Nous utiliserons du code écrit en Python pour comprendre et implémenter ce réseau de neurones étape par étape.
Un réseau de neurones est un modèle informatique qui imite un système nerveux biologique et est utilisé pour traiter des données d'entrée complexes. Cet article aidera les lecteurs à comprendre les principes de base et les concepts clés des réseaux de neurones en mettant en œuvre un simple réseau de neurones à perceptron multicouche (MLP).

Composition de base du réseau de neurones

Un réseau de neurones est constitué de plusieurs couches, chaque couche contient un certain nombre de neurones. Ces couches peuvent être divisées en couche d'entrée, couche cachée et couche de sortie. La couche d'entrée reçoit les données d'entrée, la couche cachée traite les données et la couche de sortie génère le résultat final. Dans notre exemple, nous allons implémenter un réseau de neurones avec 2 nœuds d'entrée, 1 couche cachée (contenant 2 nœuds) et 1 nœud de sortie.

fonction d'activation

La fonction d'activation est un composant clé d'un neurone et est utilisée pour mapper la valeur d'entrée du neurone à une valeur de sortie spécifique. Dans cet exemple, nous utilisons la fonction sigmoïde comme fonction d'activation. La fonction sigmoïde mappe les valeurs d'entrée aux valeurs de sortie entre 0 et 1.

algorithme de rétropropagation

L'algorithme de rétropropagation (Backpropagation) est l'algorithme de base pour la formation des réseaux de neurones. Pendant la formation, le réseau neuronal apprend la relation de mappage entre les données d'entrée et la sortie cible en ajustant les poids et les biais. L'idée clé de l'algorithme de rétropropagation est de calculer le gradient de la fonction de perte par rapport au poids et au biais, puis de mettre à jour le poids et le biais en fonction du gradient.

fonction de perte

La fonction de perte est utilisée pour mesurer l'erreur entre la sortie du réseau neuronal et la sortie cible. Dans cet exemple, nous utilisons l'erreur quadratique moyenne comme fonction de perte. Le but d'un réseau de neurones est de minimiser une fonction de perte.

Code

Notre code implémente un simple réseau de neurones XOR. Premièrement, nous définissons la fonction d'activation et ses dérivées. Ensuite, nous avons initialisé les poids et les biais du réseau de neurones. Ensuite, nous nous entraînons à l'aide d'une boucle, en mettant à jour les poids et les biais à l'aide de l'algorithme de rétropropagation à chaque itération.
Le réseau de neurones XOR implémenté par ce code couvre les points de connaissance suivants :

Le code contient les points de connaissance suivants :

• La structure de base d'un réseau de neurones (couche d'entrée, couche cachée et couche de sortie)
• Fonction d'activation (fonction sigmoïde)
• algorithme de rétropropagation
• Fonction de perte (erreur quadratique moyenne)
• Implémentation de code Python

Pendant la formation, nous avons enregistré la valeur de perte à chaque étape itérative. Une fois la formation terminée, nous utilisons la bibliothèque matplotlib pour dessiner un graphique linéaire de la valeur de perte par rapport au nombre d'itérations.

import numpy as np

# 定义激活函数和它的导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# XOR输入和输出
X = np.array([[1, 0],
              [0, 1],
              [0, 0],
              [1, 1]])

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

# 初始化神经网络超参数
input_nodes = 2
hidden_nodes = 2
output_nodes = 1
learning_rate = 0.5
iterations = 10000
import matplotlib.pyplot as plt

# 初始化权重和偏置
np.random.seed(0)
weights_input_hidden = 2*np.random.rand(input_nodes, hidden_nodes)-1
weights_hidden_output = 2*np.random.rand(hidden_nodes, output_nodes)-1
bias_hidden = 2*np.random.rand(hidden_nodes, 1)-1
bias_output = 2*np.random.rand(output_nodes, 1)-1

# 在初始化权重和偏置之后添加此行
loss_values = []

# 训练神经网络
for i in range(iterations):
    # 前向传播
    hidden_layer = sigmoid(np.dot(X, weights_input_hidden) + bias_hidden.T)
    output_layer = sigmoid(np.dot(hidden_layer, weights_hidden_output) + bias_output.T)

    # 计算输出层误差
    output_error = y - output_layer
    output_delta = output_error * sigmoid_derivative(output_layer)

    # 计算隐藏层误差
    hidden_error = np.dot(output_delta, weights_hidden_output.T)
    hidden_delta = hidden_error * sigmoid_derivative(hidden_layer)

    # 更新权重和偏置
    weights_hidden_output += learning_rate * np.dot(hidden_layer.T, output_delta)
    weights_input_hidden += learning_rate * np.dot(X.T, hidden_delta)
    bias_hidden += learning_rate * np.sum(hidden_delta, axis=0).reshape(-1, 1)
    bias_output += learning_rate * np.sum(output_delta, axis=0).reshape(-1, 1)

    # 在训练神经网络的循环中，更新权重和偏置之后添加此行
    loss_values.append(np.mean(np.square(output_error)))

# 测试神经网络
print("测试结果：")
test_result = sigmoid(np.dot(sigmoid(np.dot(X, weights_input_hidden) + bias_hidden.T), weights_hidden_output) + bias_output.T)
print(np.round(test_result))

# 在测试神经网络之后添加以下内容
plt.figure()
plt.plot(range(1, iterations + 1), loss_values)
plt.xlabel('Epochs')
plt.ylabel('Loss Value')
plt.title('Loss Value vs. Epochs')
plt.show()

# 打印测试神经网络
print("打印测试结果：")
test_result = sigmoid(np.dot(sigmoid(np.dot(X, weights_input_hidden) + bias_hidden.T), weights_hidden_output) + bias_output.T)
rounded_test_result = np.round(test_result)

for i in range(X.shape[0]):
    print(f"For input {
      
      X[i]} output is {
      
      rounded_test_result[i][0]}")

Les résultats de sortie sont les suivants :

grâce à l'introduction et à l'implémentation du code de cet article, nous comprenons les principes de base et les concepts clés des réseaux de neurones. Nous avons implémenté un réseau de neurones XOR simple et montré comment utiliser les réseaux de neurones pour le traitement et la prédiction des données. Bien que cet exemple soit relativement simple, il couvre les concepts de base des réseaux de neurones et aide les lecteurs à établir une compréhension préliminaire des réseaux de neurones.

Dans les applications pratiques, les réseaux de neurones peuvent gérer des problèmes et des données plus complexes. Pour résoudre des problèmes plus avancés, nous pouvons augmenter le nombre de couches cachées, ajuster les fonctions d'activation ou utiliser différents algorithmes d'optimisation. Les réseaux de neurones ont un large éventail d'applications dans des domaines tels que la reconnaissance d'images, le traitement du langage naturel et la reconnaissance de la parole. Avec un apprentissage approfondi et de la pratique, nous pouvons utiliser les réseaux de neurones pour résoudre des problèmes plus pratiques.