Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Bonjour à tous, je suis Wei Xue AI. Aujourd'hui, je vais vous présenter l'explication détaillée de la fondation et du code du réseau neuronal du cours 8-PyTorch Neural Network d'ingénieur en algorithmes d'intelligence artificielle (intermédiaire). Le réseau neuronal est un modèle informatique qui imite la connexion des neurones dans le cerveau humain et est largement utilisé dans la reconnaissance d'images, le traitement du langage naturel et d'autres domaines. Cet article présentera le concept, la structure, les échantillons, la formation et l'évaluation des réseaux de neurones, ainsi que le code exécutable complet.

Explication détaillée des bases et du code du réseau neuronal

1. Concept de réseau neuronal

Un réseau de neurones est constitué d'un grand nombre de nœuds (ou neurones) et des bords reliant ces nœuds. Chaque nœud représente un neurone et chaque bord représente une connexion entre neurones. La fonction principale du réseau neuronal est d'extraire des informations utiles des données grâce à une sommation pondérée et une transformation non linéaire des données d'entrée.

2. Structure du réseau neuronal

Les réseaux de neurones sont généralement divisés en couche d'entrée, couche cachée et couche de sortie. La couche d'entrée reçoit des données externes, la couche cachée traite les données et la couche de sortie génère le résultat final. Les nœuds de chaque couche sont connectés aux nœuds de la couche suivante et chaque connexion a un poids correspondant.

2.1 Formule de calcul du réseau neuronal

La sortie du réseau neuronal peut être calculée par la formule suivante :
$${un}^{(l)}=F(j^{(l)})$$
$$j^{(l)}=m^{(l)}{un}^{(l-1)}+b^{(l)}$$
dans,${un}^{(l)}$ Indique le premier$l$ La sortie de la couche,$j^{(l)}$ Indique le premier$l$ Le résultat de la sommation pondérée des couches,$m^{(l)}$ et$b^{(l)}$ Représentent respectivement les$l$ poids et biais des couches,$F(\cdot )$ représente la fonction d'activation.

2.2 Code exécutable

Voici un exemple de structure simple de réseau neuronal :

import numpy as np
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
def feedforward(X, weights, biases):
    a = X
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        a = sigmoid(z)
    return a
# 定义输入数据
X = np.array([[1, 2], [3, 4]])
# 定义权重和偏置
weights = [np.array([[0.1, 0.2], [0.3, 0.4]]), np.array([[0.5], [0.6]])]
biases = [np.array([0.1, 0.2]), np.array([0.3])]
# 计算输出
output = feedforward(X, weights, biases)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. Échantillon de réseau neuronal

Un échantillon d'un réseau neuronal comprend des données d'entrée et des étiquettes correspondantes. Pendant le processus de formation, le réseau neuronal ajuste en permanence les poids et les biais pour rendre le résultat aussi proche que possible de l'étiquette.

3.1 Fonction de perte

L'objectif de formation des réseaux de neurones est de minimiser la fonction de perte. Les fonctions de perte couramment utilisées incluent l'erreur quadratique moyenne (MSE) et la perte d'entropie croisée. La formule de l’erreur quadratique moyenne est la suivante :
$$J(m,b)=\frac{1}{2m}\sum _{je=1}^m({et}^{(je)}-{un}^{(je)}{)}^2$$
dans,$m$ représente le nombre d'échantillons,${et}^{(je)}$ et${un}^{(je)}$ Représentent respectivement les$je$ étiquettes et valeurs prédites des échantillons.

3.2 Code exécutable

Voici un exemple simple de génération d’échantillons et de calcul de perte :

import numpy as np
def mse_loss(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)
# 定义标签
y_true = np.array([[1], [0]])
# 计算损失
loss = mse_loss(y_true, output)
print(loss)
1
2
3
4
5
6
7
8

4. Formation des réseaux de neurones

Le processus de formation du réseau neuronal comprend la propagation vers l'avant et la propagation arrière. La propagation directe calcule la sortie du réseau neuronal et la rétropropagation calcule le gradient de la fonction de perte par rapport aux poids et aux biais, et met à jour les poids et les biais.

4.1 Rétropropagation

L'algorithme de rétropropagation calcule les gradients via la règle de chaîne.Pour le premier$l$ poids de la couche$m^{(l)}$, son gradient peut être exprimé comme suit :
$$\frac{\partial J}{\partial m^{(l)}}={un}^{(l-1)}\cdot (F^{\prime }(j^{(l)})\cdot {\delta }^{(l)})$$
dans,${\delta }^{(l)}$ Indique le premier$l$ erreur de couche,$F^{\prime }(\cdot )$ représente la dérivée de la fonction d'activation.

4.2 Code pour la formation des réseaux neuronaux

Voici un exemple simple de formation sur un réseau neuronal :

import numpy as np
def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))
def backpropagation(X, y_true, weights, biases):
    gradients_w = [np.zeros(w.shape) for w in weights]
    gradients_b = [np.zeros(b.shape) for b in biases]
    # 前向传播
    a = X
    activations = [a]
    zs = []
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        zs.append(z)
        a = sigmoid(z)
        activations.append(a)
    # 计算输出层误差
    delta = activations[-1] - y_true
    gradients_b[-1] = delta
    gradients_w[-1] = np.dot(activations[-2].T, delta)
    # 反向传播
    for l in range(2, len(weights) + 1):
        z = zs[-l]
        sp = sigmoid_derivative(z)
        delta = np.dot(delta, weights[-l + 1].T) * sp
        gradients_b[-l] = delta
        gradients_w[-l] = np.dot(activations[-l - 1].T, delta)
    return gradients_w, gradients_b
# 定义学习率
learning_rate = 0.1
# 进行一次梯度下降
gradients_w, gradients_b = backpropagation(X, y_true, weights, biases)
# 更新权重和偏置
for w, grad_w in zip(weights, gradients_w):
    w -= learning_rate * grad_w
for b, grad_b in zip(biases, gradients_b):
    b -= learning_rate * grad_b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

5. Évaluation des réseaux de neurones

L'évaluation des réseaux de neurones se fait généralement en calculant la valeur de la fonction de précision ou de perte sur l'ensemble de test. La précision fait référence au rapport entre le nombre d’échantillons correctement prédits par le modèle et le nombre total d’échantillons.

5.1 Précision

La formule de calcul de la précision est la suivante :
$$\text{Précision}=\frac{\text{Nombre de prédictions correctes}}{\text{Nombre total de prédictions}}$$

5.2 Mise en œuvre du code

Voici un exemple simple d’évaluation d’un réseau neuronal :

def predict(X, weights, biases):
    a = X
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        a = sigmoid(z)
    return np.round(a)
# 定义测试数据
X_test = np.array([[2, 3], [4, 5]])
# 进行预测
predictions = predict(X_test, weights, biases)
print(predictions)
# 计算准确率
y_test = np.array([[1], [0]])
accuracy = np.mean(predictions == y_test)
print("Accuracy:", accuracy)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Résumer

Dans cet article, nous avons implémenté un réseau neuronal simple, comprenant la propagation vers l'avant, la rétro-propagation, la descente de gradient et le processus d'évaluation. Bien que ce réseau soit simple, il démontre les principes de base et les méthodes de mise en œuvre des réseaux de neurones. Dans les applications pratiques, la structure des réseaux de neurones sera plus complexe, impliquant davantage de couches et de nœuds, ainsi que des algorithmes d'optimisation et des techniques de régularisation plus avancés. De plus, les cadres modernes d'apprentissage en profondeur (tels que TensorFlow et PyTorch) offrent une mise en œuvre plus efficace et des fonctions de différenciation automatique, ce qui rend la construction et la formation de réseaux neuronaux plus pratiques.