Condivisione della tecnologia

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

Ciao a tutti, sono Wei Xue AI. Oggi vi presenterò la spiegazione dettagliata delle basi della rete neurale e del codice del corso Intermediate per Ingegnere degli algoritmi di intelligenza artificiale 8-PyTorch Neural Network. La rete neurale è un modello informatico che imita la connessione dei neuroni nel cervello umano ed è ampiamente utilizzato nel riconoscimento delle immagini, nell'elaborazione del linguaggio naturale e in altri campi. Questo articolo introdurrà il concetto, la struttura, gli esempi, l'addestramento e la valutazione delle reti neurali, insieme al codice eseguibile completo.

Spiegazione dettagliata delle basi e del codice delle reti neurali

1. Concetto di rete neurale

Una rete neurale è costituita da un gran numero di nodi (o neuroni) e dai bordi che collegano questi nodi. Ogni nodo rappresenta un neurone e ogni bordo rappresenta una connessione tra neuroni. La funzione principale della rete neurale è estrarre informazioni utili dai dati attraverso la somma ponderata e la trasformazione non lineare dei dati di input.

2. Struttura della rete neurale

Le reti neurali sono generalmente divise in livello di input, livello nascosto e livello di output. Il livello di input riceve dati esterni, il livello nascosto elabora i dati e il livello di output restituisce il risultato finale. I nodi in ogni strato sono collegati ai nodi nello strato successivo e ciascuna connessione ha un peso corrispondente.

2.1 Formula per il calcolo della rete neurale

L'output della rete neurale può essere calcolato con la seguente formula:
$${UN}^{(l)}=F({lo}^{(l)})$$
$${lo}^{(l)}={io}^{(l)}{UN}^{(l-1)}+B^{(l)}$$
In,${UN}^{(l)}$ Indica il primo$l$ L'output dello strato,${lo}^{(l)}$ Indica il primo$l$ Il risultato della somma ponderata degli strati,${io}^{(l)}$ E$B^{(l)}$ Rappresentano rispettivamente il$l$ pesi e bias dei livelli,$F(\cdot )$ rappresenta la funzione di attivazione.

2.2 Codice eseguibile

Ecco un esempio di una semplice struttura di rete neurale:

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. Esempio di rete neurale

Un campione di una rete neurale include dati di input e etichette corrispondenti. Durante il processo di addestramento, la rete neurale regola continuamente i pesi e i pregiudizi per rendere l'output il più vicino possibile all'etichetta.

3.1 Funzione di perdita

L'obiettivo dell'addestramento delle reti neurali è ridurre al minimo la funzione di perdita. Le funzioni di perdita comunemente utilizzate includono l'errore quadratico medio (MSE) e la perdita di entropia incrociata. La formula per l'errore quadratico medio è la seguente:
$$J(io,B)=\frac{1}{2M}\sum _{ioooooo=1}^M(e^{(ioooooo)}-{UN}^{(ioooooo)}{)}^2$$
In,$M$ rappresenta il numero di campioni,$e^{(ioooooo)}$ E${UN}^{(ioooooo)}$ Rappresentano rispettivamente il$ioooooo$ etichette e valori previsti dei campioni.

3.2 Codice eseguibile

Ecco un semplice esempio di generazione del campione e calcolo della perdita:

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. Addestramento delle reti neurali

Il processo di addestramento della rete neurale include la propagazione in avanti e la propagazione all'indietro. La propagazione in avanti calcola l'output della rete neurale, mentre la propagazione all'indietro calcola il gradiente della funzione di perdita rispetto ai pesi e ai bias e aggiorna i pesi e i bias.

4.1 Propagazione all'indietro

L'algoritmo di backpropagation calcola i gradienti tramite la regola della catena.Per la prima$l$ peso dello strato${io}^{(l)}$, il suo gradiente può essere espresso come:
$$\frac{\partial J}{\partial {io}^{(l)}}={UN}^{(l-1)}\cdot (F^{\prime }({lo}^{(l)})\cdot {\delta }^{(l)})$$
In,${\delta }^{(l)}$ Indica il primo$l$ errore di livello,$F^{\prime }(\cdot )$ rappresenta la derivata della funzione di attivazione.

4.2 Codice per l'addestramento della rete neurale

Ecco un semplice esempio di addestramento della rete neurale:

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. Valutazione delle Reti Neurali

La valutazione delle reti neurali viene solitamente eseguita calcolando il valore della precisione o della funzione di perdita sul set di test. L'accuratezza si riferisce al rapporto tra il numero di campioni correttamente previsti dal modello e il numero totale di campioni.

5.1 Precisione

La formula di calcolo per la precisione è la seguente:
$$\text{Precisione}=\frac{\text{Numero di previsioni corrette}}{\text{Numero totale di previsioni}}$$

5.2 Attuazione del codice

Ecco un semplice esempio di valutazione della rete neurale:

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

Riassumere

In questo articolo, abbiamo implementato una semplice rete neurale, inclusa la propagazione in avanti, la propagazione all'indietro, la discesa del gradiente e il processo di valutazione. Sebbene questa rete sia semplice, dimostra i principi di base e i metodi di implementazione delle reti neurali. Nelle applicazioni pratiche, la struttura delle reti neurali sarà più complessa, coinvolgendo più strati e nodi, nonché algoritmi di ottimizzazione e tecniche di regolarizzazione più avanzati. Inoltre, i moderni framework di deep learning (come TensorFlow e PyTorch) forniscono un’implementazione più efficiente e funzioni di differenziazione automatica, rendendo più conveniente la costruzione e l’addestramento delle reti neurali.