Berbagi teknologi

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

Halo semuanya, saya Wei Xue AI. Hari ini saya akan memperkenalkan kepada Anda penjelasan rinci tentang dasar jaringan saraf dan kode Kursus Insinyur Algoritma Kecerdasan Buatan (Menengah) 8-Jaringan Syaraf PyTorch. Jaringan saraf adalah model komputasi yang meniru koneksi neuron di otak manusia dan banyak digunakan dalam pengenalan gambar, pemrosesan bahasa alami, dan bidang lainnya. Artikel ini akan memperkenalkan konsep, struktur, sampel, pelatihan dan evaluasi jaringan saraf, beserta kode lengkap yang dapat dijalankan.

Penjelasan mendetail tentang dasar-dasar dan kode jaringan saraf

1. Konsep jaringan saraf

Jaringan saraf terdiri dari sejumlah besar node (atau neuron) dan tepi yang menghubungkan node-node ini. Setiap node mewakili sebuah neuron, dan setiap edge mewakili koneksi antar neuron. Fungsi utama jaringan saraf adalah mengekstrak informasi berguna dari data melalui penjumlahan tertimbang dan transformasi nonlinier dari data masukan.

2. Struktur jaringan saraf

Jaringan saraf biasanya dibagi menjadi lapisan masukan, lapisan tersembunyi, dan lapisan keluaran. Lapisan masukan menerima data eksternal, lapisan tersembunyi memproses data, dan lapisan keluaran mengeluarkan hasil akhir. Node pada setiap lapisan dihubungkan ke node pada lapisan berikutnya, dan setiap koneksi mempunyai bobot yang sesuai.

2.1 Rumus perhitungan jaringan saraf

Output dari jaringan saraf dapat dihitung dengan rumus berikut:
$$A^{(aku)}=F({dari}^{(aku)})$$
$${dari}^{(aku)}={aku}^{(aku)}{A}^{(aku-1)}+B^{(aku)}$$
di dalam,$A^{(aku)}$ Menunjukkan yang pertama$aku$ Keluaran dari lapisan,${dari}^{(aku)}$ Menunjukkan yang pertama$aku$ Hasil penjumlahan tertimbang dari lapisan-lapisan tersebut,${aku}^{(aku)}$ Dan$B^{(aku)}$ Masing-masing mewakili$aku$ bobot dan bias lapisan,$F(\cdot )$ mewakili fungsi aktivasi.

2.2 Kode yang dapat dijalankan

Berikut adalah contoh struktur jaringan saraf sederhana:

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. Contoh jaringan saraf

Contoh jaringan saraf mencakup data masukan dan label yang sesuai. Selama proses pelatihan, jaringan saraf terus-menerus menyesuaikan bobot dan bias untuk membuat keluaran sedekat mungkin dengan label.

3.1 Fungsi kerugian

Tujuan pelatihan jaringan saraf adalah untuk meminimalkan fungsi kerugian. Fungsi kerugian yang umum digunakan mencakup mean square error (MSE) dan cross-entropy loss. Rumus mean square error adalah sebagai berikut:
$$J(aku,B)=\frac{1}{2M}\sum _{Saya=1}^M({kamu}^{(Saya)}-A^{(Saya)}{)}^2$$
di dalam,$M$ mewakili jumlah sampel,${kamu}^{(Saya)}$ Dan$A^{(Saya)}$ Masing-masing mewakili$Saya$ label dan nilai prediksi sampel.

3.2 Kode yang dapat dijalankan

Berikut adalah contoh sederhana pembuatan sampel dan penghitungan kerugian:

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. Pelatihan jaringan syaraf tiruan

Proses pelatihan jaringan syaraf tiruan meliputi propagasi maju dan propagasi mundur. Propagasi maju menghitung keluaran jaringan saraf, dan propagasi mundur menghitung gradien fungsi kerugian sehubungan dengan bobot dan bias, serta memperbarui bobot dan bias.

4.1 Propagasi mundur

Algoritme propagasi mundur menghitung gradien melalui aturan rantai.Untuk yang pertama$aku$ berat lapisan${aku}^{(aku)}$, gradiennya dapat dinyatakan sebagai:
$$\frac{\partial J}{\partial {aku}^{(aku)}}=A^{(aku-1)}\cdot (F^{\prime }({dari}^{(aku)})\cdot {\delta }^{(aku)})$$
di dalam,${\delta }^{(aku)}$ Menunjukkan yang pertama$aku$ kesalahan lapisan,$F^{\prime }(\cdot )$ mewakili turunan dari fungsi aktivasi.

4.2 Kode untuk pelatihan jaringan saraf

Berikut adalah contoh pelatihan jaringan saraf sederhana:

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. Evaluasi Jaringan Syaraf Tiruan

Evaluasi jaringan syaraf tiruan biasanya dilakukan dengan menghitung nilai fungsi akurasi atau kerugian pada set pengujian. Akurasi mengacu pada rasio jumlah sampel yang diprediksi dengan benar oleh model terhadap jumlah total sampel.

5.1 Akurasi

Rumus perhitungan ketelitiannya adalah sebagai berikut:
$$\text{Ketepatan}=\frac{\text{Jumlah prediksi yang benar}}{\text{Jumlah total prediksi}}$$

5.2 Penerapan kode

Berikut adalah contoh evaluasi jaringan saraf sederhana:

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

Meringkaskan

Dalam artikel ini, kami menerapkan jaringan saraf sederhana, termasuk propagasi maju, propagasi mundur, penurunan gradien, dan proses evaluasi. Meskipun jaringan ini sederhana, jaringan ini menunjukkan prinsip dasar dan metode implementasi jaringan saraf. Dalam aplikasi praktis, struktur jaringan saraf akan menjadi lebih kompleks, melibatkan lebih banyak lapisan dan node, serta algoritma optimasi dan teknik regularisasi yang lebih canggih. Selain itu, framework deep learning modern (seperti TensorFlow dan PyTorch) memberikan implementasi yang lebih efisien dan fungsi diferensiasi otomatis, sehingga membuat konstruksi dan pelatihan jaringan neural menjadi lebih nyaman.