Teknologian jakaminen

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

Hei kaikki, olen Wei Xue AI Tänään esittelen teille yksityiskohtaisen selityksen tekoälyn algoritmi-insinöörin (keskitason) kurssin 8-PyTorch hermoverkon perustasta ja koodista. Neuroverkko on laskentamalli, joka jäljittelee neuronien yhteyttä ihmisaivoissa ja jota käytetään laajasti kuvantunnistuksessa, luonnollisen kielen käsittelyssä ja muilla aloilla. Tässä artikkelissa esitellään hermoverkkojen käsite, rakenne, näytteet, koulutus ja arviointi sekä täydellinen ajettava koodi.

Yksityiskohtainen selitys neuroverkon perusteista ja koodista

1. Neuroverkon käsite

Hermoverkko koostuu suuresta määrästä solmuja (tai neuroneja) ja näitä solmuja yhdistävistä reunoista. Jokainen solmu edustaa hermosolua ja jokainen reuna edustaa neuronien välistä yhteyttä. Neuraaliverkon päätehtävä on poimia tiedoista hyödyllistä tietoa painotetun summauksen ja syöttötiedon epälineaarisen muunnoksen avulla.

2. Neuraaliverkon rakenne

Neuroverkot jaetaan yleensä tulokerrokseen, piilotettuun kerrokseen ja tuloskerrokseen. Syöttökerros vastaanottaa ulkoista dataa, piilotettu kerros käsittelee tiedot ja tulostuskerros tulostaa lopputuloksen. Jokaisen kerroksen solmut on yhdistetty seuraavan kerroksen solmuihin, ja jokaisella yhteydellä on vastaava paino.

2.1 Neuroverkon laskentakaava

Neuroverkon lähtö voidaan laskea seuraavalla kaavalla:
$$a^{(l)}=f(z^{(l)})$$
$$z^{(l)}=w^{(l)}{a}^{(l-1)}+b^{(l)}$$
sisään,$a^{(l)}$ Osoittaa ensimmäisen$l$ kerroksen tulos,$z^{(l)}$ Osoittaa ensimmäisen$l$ kerrosten painotettu summaustulos,$w^{(l)}$ ja$b^{(l)}$ Edustavat vastaavasti$l$ kerrosten painot ja poikkeamat,$f(\cdot )$ edustaa aktivointitoimintoa.

2.2 Suoritettava koodi

Tässä on esimerkki yksinkertaisesta hermoverkkorakenteesta:

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. Näyte neuroverkosta

Näyte neuroverkosta sisältää syöttödataa ja vastaavat tunnisteet. Harjoitteluprosessin aikana hermoverkko säätää jatkuvasti painoja ja poikkeamia, jotta tulos olisi mahdollisimman lähellä etikettiä.

3.1 Häviötoiminto

Neuraaliverkkojen harjoitustavoitteena on minimoida häviöfunktio. Yleisesti käytettyjä häviöfunktioita ovat keskimääräinen neliövirhe (MSE) ja ristientropiahäviö. Keskineliövirheen kaava on seuraava:
$$J(w,b)=\frac{1}{2m}\sum _{i=1}^m(y^{(i)}-a^{(i)}{)}^2$$
sisään,$m$ edustaa näytteiden määrää,$y^{(i)}$ ja$a^{(i)}$ Edustavat vastaavasti$i$ näytteiden etiketit ja ennustetut arvot.

3.2 Suoritettava koodi

Tässä on yksinkertainen esimerkki näytteen muodostamisesta ja häviön laskemisesta:

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. Neuroverkkojen koulutus

Neuroverkon koulutusprosessi sisältää eteenpäin etenemisen ja takaisinetenemisen. Eteenpäin eteneminen laskee hermoverkon lähdön, ja backpropagation laskee häviöfunktion gradientin painojen ja harhojen suhteen sekä päivittää painot ja harhat.

4.1 Takaisinlisäys

Takaisinetenemisalgoritmi laskee gradientit ketjusäännön avulla.Ensimmäisen$l$ kerroksen paino$w^{(l)}$, sen gradientti voidaan ilmaista seuraavasti:
$$\frac{\partial J}{\partial w^{(l)}}=a^{(l-1)}\cdot (f^{\prime }(z^{(l)})\cdot {\delta }^{(l)})$$
sisään,${\delta }^{(l)}$ Osoittaa ensimmäisen$l$ kerrosvirhe,$f^{\prime }(\cdot )$ edustaa aktivointifunktion johdannaista.

4.2 Neuroverkkokoulutuksen koodi

Tässä on yksinkertainen neuroverkkokoulutusesimerkki:

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. Neuraaliverkkojen arviointi

Neuraaliverkkojen arviointi tehdään yleensä laskemalla testijoukon tarkkuus- tai häviöfunktion arvo. Tarkkuus viittaa mallin oikein ennustaman näytteiden määrän suhdetta näytteiden kokonaismäärään.

5.1 Tarkkuus

Tarkkuuden laskentakaava on seuraava:
$$\text{Tarkkuus}=\frac{\text{Oikeiden ennusteiden määrä}}{\text{Ennusteiden kokonaismäärä}}$$

5.2 Koodin käyttöönotto

Tässä on yksinkertainen neuroverkon arviointiesimerkki:

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

Tee yhteenveto

Tässä artikkelissa toteutimme yksinkertaisen hermoverkon, joka sisältää eteenpäin etenemisen, takaisin etenemisen, gradientin laskeutumisen ja arviointiprosessin. Vaikka tämä verkko on yksinkertainen, se esittelee neuroverkkojen perusperiaatteet ja toteutustavat. Käytännön sovelluksissa hermoverkkojen rakenne tulee olemaan monimutkaisempi, sisältäen enemmän kerroksia ja solmuja sekä kehittyneempiä optimointialgoritmeja ja regularisointitekniikoita. Lisäksi nykyaikaiset syväoppimiskehykset (kuten TensorFlow ja PyTorch) tarjoavat tehokkaamman toteutuksen ja automaattisen eriyttämistoiminnon, mikä helpottaa hermoverkkojen rakentamista ja koulutusta.