第五章 神經網絡

5.1神經元模型

神經網絡中最基本的成分是神經元。每個神經元與其他神經元相連,當它“興奮”時,就會向相連的神經元發(fā)送化學物質，從而改變這些神經元內的電位;如果某神經元的電位超過了一個“閾值”(threshold)，那么它就會被激活,即“興奮”起來,向其他神經元發(fā)送化學物質.

MP神經元模型：神經元接收到來自n個其他神經元傳遞過來的輸入信號,這些輸入信號通過帶權重的連接進行傳遞,神經元接收到的總輸入值將與神經元的閾值進行比，然后通過激活函數處理以產生神經元的輸出。
兩個常見的激活函數：

5.2感知機與多層網絡

感知機(Perceptron)由兩層神經元組成，輸入層接收外界輸入信號后傳遞給輸出層，輸出層是 M-P神經元,亦稱“閾值邏輯單元”：
感知機容易實現邏輯與、或、非：

• 與（$x_1\wedge x_2$）：$y=f(1?x_1+1?x_2?2)$，僅當$x_1=x_2=1$，$y=1$
• 或（$x_1\vee x_2$）：$y=f(1?x_1+1?x_2?0.5)$，當$x_1=1$或$x_2=1$，$y=1$
• 非（$?x_1$）：$y=f(?0.6?x_1+0.5)$，當$x_1=0$，$y=1$；當$x_1=1$，$y=0$

如果存在一個線性超平面兩類模式分開，則感知機可收斂；否則振蕩，如下圖的異或

要解決非線性可分問題，需要多層功能神經元。
兩層感知機：輸入層和輸出層加一層隱含層

多層前饋神經網絡：每一層神經元全互連,神經元之間不存在同層連接,也不存在跨層連接

5.3誤差逆?zhèn)鞑ニ惴?/h3>

誤差逆?zhèn)鞑ニ惴ǎ˙P算法）是迄今最成功的神經學習網絡（通常說BP網絡時指的是多層前饋神經網絡）。

訓練集：$$D=\{({\mathbf{x}}_1,{\mathbf{y}}_1),({\mathbf{x}}_2,{\mathbf{y}}_2),\dots ,({\mathbf{x}}_m,{\mathbf{y}}_m)\},{\mathbf{x}}_i\in {\mathbb{R}}^d,{\mathbf{y}}_i\in {\mathbb{R}}^l,$$
輸入$d$個屬性，輸出$l$維向量。
則采用輸入層$d$個神經元$x$、$q$個隱層神經元$b$、輸出層$l$個神經元$y$的多層前饋神經網絡（BP網絡）。
臨時變量：輸入層為第$i$個神經元、隱層為第$h$個神經元、輸出層為第$j$層神經元
連接權：輸入層第i個神經元與隱層第h個神經元的連接權為$v_{ih}$、隱層第$h$個神經元與輸出層第$j$個神經元的連接權為$w_{hj}$
閾值：隱層第$h$個神經元的閾值：${\gamma }_h$、輸出層第$j$個神經元的閾值：${\theta }_j$

輸入：第$h$個神經元的輸入為${\alpha }_h={\sum }_{i=1}^d{v}_{ih}{x}_i$，輸出層第$j$個神經元的為${\beta }_j={\sum }_{h=1}^q{w}_{hj}{b}_h$

假設激活函數使用Sigmoid函數。假定神經網絡的輸出為$y_k=({\hat{y}}_1^k,{\hat{y}}_2^k,\dots ,{\hat{y}}_l^k)$，即$${\hat{y}}_j^k=f({\beta }_j?{\theta }_j)$$ 網絡均方誤差為$$E_k=\frac{1}{2}\sum _{j=1}^l({\hat{y}}_j^k?y_j^k{)}^2$$

需要確定的參數：

1. 輸入層到隱層dq個權值
2. 隱層到輸出層ql個權值
3. q個隱層神經元的閾值
4. l個輸出層神經元的閾值

$$\begin{array}{rl}{g}_j& =?\frac{?E_k}{?{\hat{y}}_j^k}?\frac{?{\hat{y}}_j^k}{?{\beta }_j}\\ & =?({\hat{y}}_j^k?y_j^k)f^{\prime }({\beta }_j?{\theta }_j)\\ & ={\hat{y}}_j^k(1?{\hat{y}}_j^k)(y_j^k?{\hat{y}}_j^k).\end{array}$$

$$\begin{array}{c}\Delta w_{hj}=\eta g_j{b}_h\\ \Delta {\theta }_j=?\eta g_j\\ \Delta v_{ih}=\eta e_h{x}_i\\ \Delta {\gamma }_h=?\eta e_h\end{array}$$

$$\begin{array}{rl}{e}_h& =?\frac{?E_k}{?b_h}?\frac{?b_h}{?{\alpha }_h}\\ & =?\sum _{j=1}^l\frac{?E_k}{?{\beta }_j}?\frac{?{\beta }_j}{?b_h}{f}^{\prime }({\alpha }_h?{\gamma }_h)\\ & =\sum _{j=1}^l{w}_{hj}{g}_j{f}^{\prime }({\alpha }_h?{\gamma }_h)\\ & =b_h(1?b_h)\sum _{j=1}^l{w}_{hj}{g}_j\end{array}$$

誤差逆?zhèn)鞑ニ惴?br>輸入：訓練集$D=\{({\mathbf{x}}_1,{\mathbf{y}}_1),({\mathbf{x}}_2,{\mathbf{y}}_2),\dots ,({\mathbf{x}}_m,{\mathbf{y}}_m)\}$，學習率$\eta$
過程：

在(0,1)范圍內隨機初始化網絡中所有連接權和閾值
repeat：
    for (xk, yk) in D :
        計算當前樣本的輸出y'k
        計算輸出層神經元的梯度項g_j
        計算隱層神經元的梯度項e_h
        更新連接權w_hj，v_ih與閾值theta_j，gamma_h
    end for
until 達到停止條件

輸出：連接權與閾值確定的多層前饋神經網絡

5.4全局最小和局部最小

基于梯度的搜索中,我們從某些初始解出發(fā),迭代尋找最優(yōu)參數值.每次迭代中,我們先計算誤差函數在當前點的梯度,然后根據梯度確定搜索方向.例如，由于負梯度方向是函數值下降最快的方向,因此梯度下降法就是沿著負梯度方向搜索最優(yōu)解．若誤差函數在當前點的梯度為零,則已達到局部極小，更新量將為零,這意味著參數的迭代更新將在此停止.然而，如果誤差函數具有多個局部極小，則不能保證找到的解是全局最小.

在現實任務中，人們常采用以下策略來試圖“跳出”局部極小，從而進一步接近全局最小:

1. 以多組不同參數值初始化多個神經網絡,按標準方法訓練后,取其中誤差最小的解作為最終參數.這相當于從多個不同的初始點開始搜索,這樣就可能陷入不同的局部極小，從中進行選擇有可能獲得更接近全局最小的結果.
2. 使用“模擬退火”(simulated annealing)技術.模擬退火在每一步都以一定的概率接受比當前解更差的結果,從而有助于“跳出”局部極小.在每步迭代過程中,接受“次優(yōu)解”的概率要隨著時間的推移而逐漸降低,從而保證算法穩(wěn)定.
3. 使用隨機梯度下降.與標準梯度下降法精確計算梯度不同,隨機梯度下降法在計算梯度時加入了隨機因素.于是,即便陷入局部極小點,它計算出的梯度仍可能不為零,這樣就有機會跳出局部極小繼續(xù)搜索.

上述用于跳出局部極小的技術大多是啟發(fā)式,理論上.尚缺乏保障.

5.5其他常見神經網絡

5.5.1RBF網絡

RBF（徑向基函數）網絡是一種常用于模式識別和函數逼近任務的人工神經網絡。RBF網絡由三層組成：輸入層、具有徑向基函數神經元的隱藏層和輸出層：

1. 輸入層：輸入層接收輸入數據，這些數據可以是數值或分類變量。輸入層的每個神經元代表輸入數據的一個特征或屬性。
2. 隱藏層：隱藏層包含徑向基函數神經元。該層的每個神經元使用徑向基函數計算其輸入與輸入空間中的中心點之間的相似性。徑向基函數通常是高斯函數。每個隱藏神經元的輸出表示該神經元基于輸入數據的激活水平。
3. 輸出層：輸出層將隱藏層的激活組合起來產生網絡的最終輸出。

RPF網絡可表示為$$\phi (\mathbf{x})=\sum _{i=1}^q{w}_i\rho (\mathbf{x},{\mathbf{c}}_i)$$常用高斯徑向基函數：$$\rho (\mathbf{x},{\mathbf{c}}_i)=e^{?{\beta }_i\Vert \mathbf{x}?{\mathbf{c}}_i{\Vert }^2}$$

5.5.2ART網絡

ART（自適應共振理論）網絡是一種人工神經網絡，旨在模擬大腦處理和組織信息的方式。ART網絡在涉及模式識別、分類和聚類等任務中非常有用。
ART網絡的簡要工作原理：

1. 輸入層：輸入層接收輸入數據，這些數據可以是數值或分類變量。每個輸入神經元表示輸入數據的一個特征或屬性。
2. 識別層：識別層包含神經元，這些神經元將輸入模式與網絡內存中存儲的模式進行比較。這些神經元使用匹配規(guī)則（如余弦相似度或歐幾里得距離）計算輸入模式與存儲模式之間的相似性。具有最高相似性的神經元成為獲勝神經元。
3. 警覺參數：警覺參數控制網絡對新模式的敏感性。它確定輸入模式與存儲模式的相似度必須達到何種程度，識別神經元才會激活。較高的警覺值意味著網絡對接受新模式更加嚴格。
4. 重置和學習：如果輸入模式與獲勝神經元的存儲模式的相似度低于警覺閾值，網絡將將輸入模式視為新類別，并激活一個新的神經元。這個過程稱為重置。網絡會根據新模式調整其內部權重，以適應新的輸入模式。

5.5.3SOM網絡

SOM（Self-Organizing Map，自組織映射）網絡是一種常用的無監(jiān)督學習算法，用于聚類、可視化和特征提取等任務。它是一種基于神經網絡的數據降維和模式識別方法。

SOM網絡的基本原理：

1. 網絡結構：SOM網絡由一個二維的神經元網格組成，每個神經元代表一個特征向量的權重向量。
2. 自組織過程：SOM網絡通過自組織過程將輸入數據映射到神經元網格上。在初始化階段，每個神經元的權重向量被隨機初始化。然后，根據輸入數據的相似度，選擇與輸入數據最匹配的神經元作為獲勝神經元。
3. 鄰域函數：獲勝神經元及其周圍神經元的權重向量會受到調整，使它們更接近輸入數據。這種調整是通過鄰域函數實現的，鄰域函數定義了獲勝神經元周圍神經元的影響程度。
4. 迭代更新：通過反復迭代更新過程，SOM網絡逐漸調整神經元的權重向量，使其能夠更好地反映輸入數據的統(tǒng)計特性。迭代的過程中，鄰域函數逐漸減小，使得調整范圍逐漸縮小，最終形成一個聚類結果或者數據的拓撲映射。

SOM網絡能夠有效地對高維數據進行降維和聚類，同時保留了輸入數據的拓撲結構。它在可視化數據、模式識別、圖像處理等領域具有廣泛應用。

5.5.4級聯(lián)相關網絡

級聯(lián)相關網絡（Cascade Correlation Network）是一種神經網絡結構，它具有自適應的網絡拓撲和動態(tài)構建連接的能力。級聯(lián)相關網絡用于解決神經網絡訓練中的困難問題。

級聯(lián)相關網絡的基本原理：

1. 動態(tài)網絡拓撲：級聯(lián)相關網絡具有動態(tài)構建網絡拓撲的能力。它開始時只有一個輸入層和一個輸出層，沒有任何隱藏層。隱藏層是通過逐步添加神經元來動態(tài)構建的。
2. 逐步添加神經元：訓練過程中，級聯(lián)相關網絡逐步添加隱藏層神經元。每次添加一個神經元，它與前面層的神經元建立連接，并通過局部訓練算法進行訓練。新添加的神經元被訓練來最大化網絡性能的提升。
3. 反向傳播和監(jiān)督訓練：級聯(lián)相關網絡使用反向傳播算法進行監(jiān)督訓練。在每個訓練階段，新添加的神經元以及前面層的所有神經元都參與誤差反向傳播的計算和權重調整。
4. 增量訓練：級聯(lián)相關網絡采用增量訓練策略，每次只訓練一個新添加的神經元。這種增量訓練的方法使得網絡能夠有效地逐步適應和學習復雜的問題。

級聯(lián)相關網絡的一個重要特點是它可以自動決定網絡的結構和復雜度。網絡會在訓練過程中根據任務的需求動態(tài)地增加隱藏層神經元，從而適應更復雜的模式。

5.5.5Elman網絡

Elman網絡是一種遞歸神經網絡（Recurrent Neural Network，RNN）結構，也稱為簡單循環(huán)神經網絡（Simple Recurrent Neural Network）。它是一種具有反饋連接的前饋神經網絡，用于處理序列數據和時序任務。

Elman網絡的基本結構：

1. 輸入層：接收輸入數據的神經元層。每個神經元表示輸入序列中的一個元素或特征。
2. 隱藏層：包含遞歸連接的神經元層。隱藏層的神經元將前一時刻的隱藏層輸出作為輸入，并結合當前時刻的輸入數據進行計算。隱藏層的神經元可以捕捉到序列數據的時間依賴性和上下文信息。
3. 輸出層：根據隱藏層的輸出計算得出網絡的輸出結果。輸出層可以是分類器、回歸器或其他適合特定任務的結構。
4. 反饋連接：Elman網絡的特點是在隱藏層中引入反饋連接。這些反饋連接將前一時刻的隱藏層輸出反饋到當前時刻，使得網絡能夠捕捉到序列數據中的動態(tài)模式和時間相關性。

Elman網絡在序列建模、語言模型、預測、語音識別和自然語言處理等任務中具有廣泛的應用。它可以通過反向傳播算法進行訓練，也可以使用其他適當的優(yōu)化算法進行參數更新。

5.5.6Boltzmann機

Boltzmann機（Boltzmann Machine）是一種基于概率的生成式神經網絡模型。它由基本的隨機二值神經元組成，這些神經元以隨機方式相互連接，并使用能量函數進行訓練和學習。

Boltzmann機的要點：

1. 結構：Boltzmann機是一種全連接的無向圖模型，其中的神經元被分為可見神經元（Visible Neurons）和隱藏神經元（Hidden Neurons）?？梢娚窠浽峭獠枯斎氲慕邮照?，而隱藏神經元則進行內部信息的傳遞。
2. 隨機性：Boltzmann機中的神經元是隨機二值神經元，其狀態(tài)可以是0或1。每個神經元的輸出由輸入、權重和偏置的組合通過激活函數（通常是sigmoid函數）進行確定。
3. 能量函數：Boltzmann機使用能量函數來定義模型的狀態(tài)和參數。能量函數是一種衡量網絡狀態(tài)的度量，其中包括連接權重和神經元的狀態(tài)。通過調整連接權重和偏置，網絡可以自動學習模式和特征。
4. 學習：Boltzmann機的學習過程是基于馬爾可夫鏈的馬爾可夫鏈蒙特卡洛方法（Markov Chain Monte Carlo，MCMC）進行的。使用對比散度（Contrastive Divergence）等算法進行參數的迭代更新，以最小化能量函數。
5. 應用：Boltzmann機在許多領域中得到應用，包括特征學習、降維、生成模型、無監(jiān)督學習等。它可以用于模式識別、圖像處理、語音識別等任務。

需要注意的是，傳統(tǒng)的Boltzmann機存在訓練和計算復雜度高的問題。為了解決這些問題，出現了改進的變種，如受限玻爾茲曼機（Restricted Boltzmann Machine，RBM）和深度信念網絡（Deep Belief Network，DBN），它們在Boltzmann機的基礎上進行了簡化和擴展。

5.6深度學習

深度學習（Deep Learning）是一種機器學習方法，旨在模仿人腦的神經網絡結構和工作方式來處理和學習復雜的數據。深度學習通過構建深層次的神經網絡模型，利用大量的數據進行訓練，并自動學習數據的特征表示和抽象層次，從而實現高效的模式識別和數據分析。

深度學習的要點：

1. 神經網絡：深度學習的核心是神經網絡模型，它由多個層次組成，包括輸入層、隱藏層和輸出層。隱藏層可以有多個，并且通常使用非線性激活函數（如ReLU、sigmoid等）來引入非線性特征。
2. 深度結構：深度學習之所以稱為深度學習，是因為它包含多個深層的隱藏層。深度結構使得網絡能夠學習到更抽象和高級的特征表示，從而提高模型的表達能力和性能。
3. 自動特征學習：深度學習通過大量的數據和反向傳播算法，自動學習數據的特征表示。網絡根據誤差信號和梯度下降的方法調整權重和偏置，以最小化預測誤差并提高模型性能。
4. 數據驅動：深度學習是一種數據驅動的方法，它依賴于大規(guī)模的標記數據來訓練和優(yōu)化模型。數據的質量和數量對深度學習的效果至關重要。
5. 應用廣泛：深度學習在眾多領域取得了重大突破和廣泛應用，包括計算機視覺、自然語言處理、語音識別、推薦系統(tǒng)等。它在圖像分類、目標檢測、機器翻譯、智能助理等任務中取得了顯著的成果。

深度學習的發(fā)展得益于算力的提升、數據的豐富和算法的創(chuàng)新。它已經成為人工智能領域的重要技術，并在許多實際問題中展現出強大的建模和預測能力。

5.7實驗：手寫數字識別

網上給出的基本網絡結構：

然而在本數據集中，輸入圖不是1*32*32，是1*28*28。所以正確的網絡結構應該是

# -*-coding =utf-8 -*-
import torch
import matplotlib.pyplot as plt
import torchvision

# 定義數據轉換
transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize((0.1307,), (0.3081,))
])

# 加載數據集
batch_size=32
path = r'05data'
train_dataset = torchvision.datasets.MNIST(root=path, train=True,transform=transform,download =False)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dataset = torchvision.datasets.MNIST(root=path, train=True,transform=transform,download =False)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
# loader.shape=1875*[32*1*28*28,32]

# 數據集可視化
from sklearn.preprocessing import MinMaxScaler
# 歸一化轉為[0,255]
transfer=MinMaxScaler(feature_range=(0, 255)) 
def visualize_loader(batch,predicted=''): 
    # batch=[32*1*28*28,32]
    imgs=batch[0].squeeze().numpy() # 消squeeze()一維
    fig, axes = plt.subplots(4, 8, figsize=(12, 6))
    labels=batch[1].numpy()
    if str(predicted)=='':
        predicted=labels
    for i, ax in enumerate(axes.flat):
        ax.imshow(imgs[i])
        ax.set_title(predicted[i],color='black' if predicted[i]==labels[i] else 'red')
        ax.axis('off')
    plt.tight_layout()
    plt.show()


# loader.shape=1875*[32*1*28*28,32]
for batch in train_loader:       
    break
visualize_loader(batch)

上圖是對數據集的可視化。

在PyTorch的torch.nn模塊中，卷積函數Conv2d的輸入張量的形狀應為[batch_size, channels, height, width]對應數據集，無需修改（在一些架構中，可能是[batch_size, height, width, channels]）。

# 創(chuàng)建模型
import torch
import torch.nn as nn
import torch.optim as optim

# 定義模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5, stride=1)
        self.relu = nn.ReLU()
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5, stride=1)
        self.flatten=nn.Flatten()
        self.fc3 = nn.Linear(256, 120)
        self.fc4 = nn.Linear(120, 84)
        self.fc5 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.flatten(x)
        x = self.fc3(x)
        x = self.relu(x)
        x = self.fc4(x)
        x = self.relu(x)
        x = self.fc5(x)
        return x

打印模型結構

model = CNN()
print(model)

CNN(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (relu): ReLU()
  (maxpool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (fc3): Linear(in_features=256, out_features=120, bias=True)
  (fc4): Linear(in_features=120, out_features=84, bias=True)
  (fc5): Linear(in_features=84, out_features=10, bias=True)
)

import torch.optim as optim

num_epochs=1
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)
        
        # 前向傳播
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # 反向傳播和優(yōu)化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # 統(tǒng)計準確率
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        
        running_loss += loss.item()
    
    train_loss = running_loss / len(train_loader)
    train_accuracy = correct / total
    
    # 在測試集上評估模型
    model.eval()
    test_loss = 0.0
    correct = 0
    total = 0
    
    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            labels = labels.to(device)
            
            outputs = model(images)
            loss = criterion(outputs, labels)
            
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
            
            test_loss += loss.item()
    
    test_loss = test_loss / len(test_loader)
    test_accuracy = correct / total
    
    # 打印訓練過程中的損失和準確率
    print(f"Epoch [{epoch+1}/{num_epochs}] - Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")

Epoch [1/1] - Train Loss: 0.0154, Train Accuracy: 0.9951, Test Loss: 0.0109, Test Accuracy: 0.9964

#保存模型
#torch.save(model.state_dict(), '05model.pth')

# 創(chuàng)建一個新的模型實例
model = CNN()
# 加載模型的參數
model.load_state_dict(torch.load('05model.pth'))

# 測試
for batch in test_loader:       
    break
imgs=batch[0]
outputs = model(imgs)
_, predicted = torch.max(outputs.data, 1)
predicted=predicted.numpy()

print(predicted)

visualize_loader(batch,predicted)

上圖中可視化了其中的32次預測，只有第三行第四列的“8”被預測為“5”，其余均是正確。
在測試集的總體預測準確度為99.64%，正確率挺高的。文章來源地址http://www.zghlxwxcb.cn/news/detail-534877.html

到了這里，關于第五章 神經網絡與手寫體識別的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！