Technologieaustausch

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

Hallo zusammen, ich bin Wei Xue AI. Heute werde ich Ihnen die detaillierte Erklärung der neuronalen Netzwerkgrundlagen und des Codes des Kurses 8 für künstliche Intelligenz-Algorithmus-Ingenieure (Mittelstufe) – PyTorch Neural Network – vorstellen. Ein neuronales Netzwerk ist ein Computermodell, das die Verbindung von Neuronen im menschlichen Gehirn nachahmt und häufig in der Bilderkennung, der Verarbeitung natürlicher Sprache und anderen Bereichen eingesetzt wird. In diesem Artikel werden das Konzept, die Struktur, Beispiele, das Training und die Bewertung neuronaler Netze sowie vollständiger ausführbarer Code vorgestellt.

Detaillierte Erläuterung der Grundlagen und des Codes neuronaler Netze

1. Konzept des neuronalen Netzwerks

Ein neuronales Netzwerk besteht aus einer großen Anzahl von Knoten (oder Neuronen) und den Kanten, die diese Knoten verbinden. Jeder Knoten repräsentiert ein Neuron und jede Kante repräsentiert eine Verbindung zwischen Neuronen. Die Hauptfunktion des neuronalen Netzwerks besteht darin, durch gewichtete Summierung und nichtlineare Transformation der Eingabedaten nützliche Informationen aus den Daten zu extrahieren.

2. Struktur des neuronalen Netzwerks

Neuronale Netze werden üblicherweise in Eingabeschicht, verborgene Schicht und Ausgabeschicht unterteilt. Die Eingabeschicht empfängt externe Daten, die verborgene Schicht verarbeitet die Daten und die Ausgabeschicht gibt das Endergebnis aus. Knoten in jeder Schicht sind mit Knoten in der nächsten Schicht verbunden, und jede Verbindung hat eine entsprechende Gewichtung.

2.1 Berechnungsformel für neuronale Netze

Die Ausgabe des neuronalen Netzwerks kann mit der folgenden Formel berechnet werden:
$$A^{(m)}=F(z^{(m)})$$
$$z^{(m)}=m^{(m)}{A}^{(m-1)}+B^{(m)}$$
In,$A^{(m)}$ Zeigt den ersten an$m$ Die Ausgabe der Ebene,$z^{(m)}$ Zeigt den ersten an$m$ Das gewichtete Summationsergebnis der Schichten,$m^{(m)}$ Und$B^{(m)}$ Repräsentieren jeweils die$m$ Schichtgewichte und Vorspannungen,$F(\cdot )$ stellt die Aktivierungsfunktion dar.

2.2 Ausführbarer Code

Hier ist ein Beispiel für eine einfache neuronale Netzwerkstruktur:

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. Beispiel eines neuronalen Netzwerks

Ein Beispiel eines neuronalen Netzwerks umfasst Eingabedaten und entsprechende Beschriftungen. Während des Trainingsprozesses passt das neuronale Netzwerk kontinuierlich die Gewichte und Verzerrungen an, um die Ausgabe so nah wie möglich an der Beschriftung zu halten.

3.1 Verlustfunktion

Das Trainingsziel neuronaler Netze besteht darin, die Verlustfunktion zu minimieren. Zu den häufig verwendeten Verlustfunktionen gehören der mittlere quadratische Fehler (MSE) und der Kreuzentropieverlust. Die Formel für den mittleren quadratischen Fehler lautet wie folgt:
$$J(m,B)=\frac{1}{2M}\sum _{ichchchchchch=1}^M(j^{(ichchchchchch)}-A^{(ichchchchchch)}{)}^2$$
In,$M$ stellt die Anzahl der Proben dar,$j^{(ichchchchchch)}$ Und$A^{(ichchchchchch)}$ Repräsentieren jeweils die$ichchchchchch$ Etiketten und vorhergesagte Werte von Proben.

3.2 Ausführbarer Code

Hier ist ein einfaches Beispiel für die Probengenerierung und Verlustberechnung:

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. Training neuronaler Netze

Der Trainingsprozess eines neuronalen Netzwerks umfasst Vorwärtsausbreitung und Rückausbreitung. Die Vorwärtsausbreitung berechnet die Ausgabe des neuronalen Netzwerks und die Rückwärtsausbreitung berechnet den Gradienten der Verlustfunktion in Bezug auf die Gewichte und Verzerrungen und aktualisiert die Gewichte und Verzerrungen.

4.1 Backpropagation

Der Backpropagation-Algorithmus berechnet Gradienten über die Kettenregel.Zum ersten Mal$m$ Schichtgewicht$m^{(m)}$, sein Gradient kann ausgedrückt werden als:
$$\frac{\partial J}{\partial m^{(m)}}=A^{(m-1)}\cdot (F^{\prime }(z^{(m)})\cdot {\delta }^{(m)})$$
In,${\delta }^{(m)}$ Zeigt den ersten an$m$ Schichtfehler,$F^{\prime }(\cdot )$ stellt die Ableitung der Aktivierungsfunktion dar.

4.2 Code für das Training neuronaler Netze

Hier ist ein einfaches Beispiel für ein neuronales Netzwerktraining:

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. Bewertung neuronaler Netze

Die Bewertung neuronaler Netze erfolgt normalerweise durch Berechnung der Genauigkeit oder des Verlustfunktionswerts des Testsatzes. Die Genauigkeit bezieht sich auf das Verhältnis der Anzahl der vom Modell korrekt vorhergesagten Proben zur Gesamtzahl der Proben.

5.1 Genauigkeit

Die Berechnungsformel für die Genauigkeit lautet wie folgt:
$$\text{Genauigkeit}=\frac{\text{Anzahl der richtigen Vorhersagen}}{\text{Gesamtzahl der Vorhersagen}}$$

5.2 Code-Implementierung

Hier ist ein einfaches Beispiel für die Bewertung eines neuronalen Netzwerks:

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

Zusammenfassen

In diesem Artikel haben wir ein einfaches neuronales Netzwerk implementiert, einschließlich Vorwärtsausbreitung, Rückausbreitung, Gradientenabstieg und Bewertungsprozess. Obwohl dieses Netzwerk einfach ist, demonstriert es die Grundprinzipien und Implementierungsmethoden neuronaler Netzwerke. In praktischen Anwendungen wird die Struktur neuronaler Netze komplexer sein und mehr Schichten und Knoten sowie fortschrittlichere Optimierungsalgorithmen und Regularisierungstechniken umfassen. Darüber hinaus bieten moderne Deep-Learning-Frameworks (wie TensorFlow und PyTorch) eine effizientere Implementierung und automatische Differenzierungsfunktionen, wodurch der Aufbau und das Training neuronaler Netze komfortabler werden.