神經(jīng)網(wǎng)絡(luò)模型流程
神經(jīng)網(wǎng)絡(luò)模型的搭建流程，整理下自己的思路，這個(gè)過(guò)程不會(huì)細(xì)分出來(lái)，而是主流程。
在這里我主要是把整個(gè)流程分為兩個(gè)主流程，即預(yù)訓(xùn)練與推理。預(yù)訓(xùn)練過(guò)程主要是生成超參數(shù)文件與搭設(shè)神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)；而推理過(guò)程就是在應(yīng)用超參數(shù)與神經(jīng)網(wǎng)絡(luò)。
卷積神經(jīng)網(wǎng)絡(luò)的實(shí)現(xiàn)
在 聊聊卷積神經(jīng)網(wǎng)絡(luò)CNN中，將卷積神經(jīng)的理論概述了一下，現(xiàn)在要大概的實(shí)踐了。整個(gè)代碼不基于pytorch/tensorflow這類大框架，而是基于numpy庫(kù)原生來(lái)實(shí)現(xiàn)算法。pytorch/tensorflow中的算子/函數(shù)只是由別人已實(shí)現(xiàn)了，我們調(diào)用而已；而基于numpy要自己實(shí)現(xiàn)一遍，雖然并不很嚴(yán)謹(jǐn)，但用于學(xué)習(xí)足以。
源代碼是來(lái)自《深度學(xué)習(xí)入門(mén)：基于Python的理論與實(shí)現(xiàn)》，可以在 https://www.ituring.com.cn/book/1921 上獲取下載
搭建CNN
網(wǎng)絡(luò)構(gòu)成如下:
如圖所示，網(wǎng)絡(luò)的構(gòu)成是"Conv-ReLU-Pooling-Affine-ReLU-Affine-Softmax". 對(duì)于卷積層與池化層的計(jì)算，由于其是四維數(shù)據(jù)(數(shù)據(jù)量,通道,高,長(zhǎng))，不太好計(jì)算，使用im2col函數(shù)將其展開(kāi)成二維 2 × 2的數(shù)據(jù)，最后輸出時(shí)，利用numpy庫(kù)的reshape函數(shù)轉(zhuǎn)換輸出的大小，方便計(jì)算。其示意圖如下:
這樣也滿足了矩陣內(nèi)積計(jì)算的要求，即 行列數(shù)要對(duì)應(yīng)
CNN程序代碼實(shí)現(xiàn)如下:
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 為了導(dǎo)入父目錄的文件而進(jìn)行的設(shè)定
import pickle
import numpy as np
from collections import OrderedDict
from DeepLearn_Base.common.layers import *
from DeepLearn_Base.common.gradient import numerical_gradient
class SimpleConvNet:
"""簡(jiǎn)單的ConvNet
conv - relu - pool - affine - relu - affine - softmax
Parameters
----------
input_dim: 輸入數(shù)據(jù)的維度，通道、高、長(zhǎng)
conv_param: 卷積核參數(shù); filter_num:卷積核數(shù)量; filter_size:卷積核大小; stride:步幅; pad:填充
input_size : 輸入大小（MNIST的情況下為784）
hidden_size_list : 隱藏層的神經(jīng)元數(shù)量的列表（e.g. [100, 100, 100]）
output_size : 輸出大?。∕NIST的情況下為10）
activation : 'relu' or 'sigmoid'
weight_init_std : 指定權(quán)重的標(biāo)準(zhǔn)差（e.g. 0.01）
指定'relu'或'he'的情況下設(shè)定“He的初始值”
指定'sigmoid'或'xavier'的情況下設(shè)定“Xavier的初始值”
"""
def __init__(self, input_dim=(1, 28, 28),
conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
hidden_size=100, output_size=10, weight_init_std=0.01):
filter_num = conv_param['filter_num']
filter_size = conv_param['filter_size']
filter_pad = conv_param['pad']
filter_stride = conv_param['stride']
input_size = input_dim[1]
conv_output_size = (input_size - filter_size + 2*filter_pad) / filter_stride + 1
pool_output_size = int(filter_num * (conv_output_size/2) * (conv_output_size/2))
# 初始化權(quán)重
self.params = {}
self.params['W1'] = weight_init_std * \
np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
self.params['b1'] = np.zeros(filter_num)
self.params['W2'] = weight_init_std * \
np.random.randn(pool_output_size, hidden_size)
self.params['b2'] = np.zeros(hidden_size)
self.params['W3'] = weight_init_std * \
np.random.randn(hidden_size, output_size)
self.params['b3'] = np.zeros(output_size)
# 生成層
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
conv_param['stride'], conv_param['pad'])
self.layers['Relu1'] = Relu()
self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)
self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
self.layers['Relu2'] = Relu()
self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
self.last_layer = SoftmaxWithLoss()
# 需要處理數(shù)據(jù)，將輸入數(shù)據(jù)的多維與卷積核的多維分別展平后做矩陣運(yùn)算
# 在神經(jīng)網(wǎng)絡(luò)的中間層(conv,relu,pooling,affine等)的forward函數(shù)中用到了img2col與reshape結(jié)合展平數(shù)據(jù)，用向量?jī)?nèi)積運(yùn)算
def predict(self, x):
for layer in self.layers.values():
x = layer.forward(x)
return x
def loss(self, x, t):
"""求損失函數(shù)
參數(shù)x是輸入數(shù)據(jù)、t是教師標(biāo)簽
"""
y = self.predict(x)
return self.last_layer.forward(y, t)
# 計(jì)算精確度
def accuracy(self, x, t, batch_size=100):
if t.ndim != 1 : t = np.argmax(t, axis=1)
acc = 0.0
for i in range(int(x.shape[0] / batch_size)):
tx = x[i*batch_size:(i+1)*batch_size]
tt = t[i*batch_size:(i+1)*batch_size]
y = self.predict(tx)
y = np.argmax(y, axis=1)
acc += np.sum(y == tt)
return acc / x.shape[0]
def numerical_gradient(self, x, t):
"""求梯度（數(shù)值微分）
Parameters
----------
x : 輸入數(shù)據(jù)
t : 教師標(biāo)簽
Returns
-------
具有各層的梯度的字典變量
grads['W1']、grads['W2']、...是各層的權(quán)重
grads['b1']、grads['b2']、...是各層的偏置
"""
loss_w = lambda w: self.loss(x, t)
grads = {}
for idx in (1, 2, 3):
grads['W' + str(idx)] = numerical_gradient(loss_w, self.params['W' + str(idx)])
grads['b' + str(idx)] = numerical_gradient(loss_w, self.params['b' + str(idx)])
return grads
def gradient(self, x, t):
"""求梯度（誤差反向傳播法）
Parameters
----------
x : 輸入數(shù)據(jù)
t : 教師標(biāo)簽
Returns
-------
具有各層的梯度的字典變量
grads['W1']、grads['W2']、...是各層的權(quán)重
grads['b1']、grads['b2']、...是各層的偏置
"""
# forward
self.loss(x, t)
# backward
dout = 1
dout = self.last_layer.backward(dout)
layers = list(self.layers.values())
layers.reverse()
for layer in layers:
dout = layer.backward(dout)
# 設(shè)定
grads = {}
grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
return grads
def save_params(self, file_name="params.pkl"):
params = {}
for key, val in self.params.items():
params[key] = val
with open(file_name, 'wb') as f:
pickle.dump(params, f)
def load_params(self, file_name="params.pkl"):
with open(file_name, 'rb') as f:
params = pickle.load(f)
for key, val in params.items():
self.params[key] = val
for i, key in enumerate(['Conv1', 'Affine1', 'Affine2']):
self.layers[key].W = self.params['W' + str(i+1)]
self.layers[key].b = self.params['b' + str(i+1)]
激活函數(shù)與卷積函數(shù)的實(shí)現(xiàn)代碼沒(méi)有詳細(xì)的寫(xiě)出來(lái)，可以自己去下載查看
在這整個(gè)的過(guò)程中，我個(gè)人覺(jué)得最難的就是神經(jīng)網(wǎng)絡(luò)層的搭建與數(shù)據(jù)的計(jì)算。前者決定了神經(jīng)網(wǎng)絡(luò)的結(jié)構(gòu)，而后者決定了是否最終結(jié)果。通過(guò)將數(shù)據(jù)展平，才能方便，正確的進(jìn)行向量?jī)?nèi)積計(jì)算。
預(yù)訓(xùn)練
trainer.py文件是進(jìn)行神經(jīng)網(wǎng)絡(luò)訓(xùn)練的類，會(huì)統(tǒng)計(jì)執(zhí)行完一個(gè)epoch后的精確度，過(guò)程要選擇梯度更新算法，學(xué)習(xí)率，批大小，epoch次數(shù)等參數(shù)。
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 為了導(dǎo)入父目錄的文件而進(jìn)行的設(shè)定
import numpy as np
from DeepLearn_Base.common.optimizer import *
class Trainer:
"""進(jìn)行神經(jīng)網(wǎng)絡(luò)的訓(xùn)練的類
epochs: 以所有數(shù)據(jù)走完前向、后向傳播為一次;該數(shù)值表示為總次數(shù)
mini_batch_size: 100; 每批次迭代多少數(shù)據(jù)
evaluate_sample_num_per_epoch: 1000;
"""
def __init__(self, network, x_train, t_train, x_test, t_test,
epochs=20, mini_batch_size=100,
optimizer='SGD', optimizer_param={'lr':0.01},
evaluate_sample_num_per_epoch=None, verbose=True):
self.network = network
self.verbose = verbose
self.x_train = x_train
self.t_train = t_train
self.x_test = x_test
self.t_test = t_test
self.epochs = epochs
self.batch_size = mini_batch_size
self.evaluate_sample_num_per_epoch = evaluate_sample_num_per_epoch
# optimzer: 梯度更新優(yōu)化器; 更新多種梯度更新算法實(shí)現(xiàn)梯度更新.
optimizer_class_dict = {'sgd':SGD, 'momentum':Momentum, 'nesterov':Nesterov,
'adagrad':AdaGrad, 'rmsprpo':RMSprop, 'adam':Adam}
self.optimizer = optimizer_class_dict[optimizer.lower()](**optimizer_param)
self.train_size = x_train.shape[0]
self.iter_per_epoch = max(self.train_size / mini_batch_size, 1)
self.max_iter = int(epochs * self.iter_per_epoch)
self.current_iter = 0
self.current_epoch = 0
self.train_loss_list = []
self.train_acc_list = []
self.test_acc_list = []
def train_step(self):
# 隨機(jī)挑選批次的數(shù)據(jù)進(jìn)行梯度更新
batch_mask = np.random.choice(self.train_size, self.batch_size)
x_batch = self.x_train[batch_mask]
t_batch = self.t_train[batch_mask]
# 開(kāi)始更新梯度
grads = self.network.gradient(x_batch, t_batch)
self.optimizer.update(self.network.params, grads)
# 計(jì)算損失
loss = self.network.loss(x_batch, t_batch)
self.train_loss_list.append(loss)
if self.verbose: print("train loss:" + str(loss))
# 計(jì)算是否完成了一個(gè)epoch的執(zhí)行
if self.current_iter % self.iter_per_epoch == 0:
self.current_epoch += 1
x_train_sample, t_train_sample = self.x_train, self.t_train
x_test_sample, t_test_sample = self.x_test, self.t_test
if not self.evaluate_sample_num_per_epoch is None:
t = self.evaluate_sample_num_per_epoch
x_train_sample, t_train_sample = self.x_train[:t], self.t_train[:t]
x_test_sample, t_test_sample = self.x_test[:t], self.t_test[:t]
train_acc = self.network.accuracy(x_train_sample, t_train_sample)
test_acc = self.network.accuracy(x_test_sample, t_test_sample)
self.train_acc_list.append(train_acc)
self.test_acc_list.append(test_acc)
if self.verbose: print("=== epoch:" + str(self.current_epoch) + ", train acc:" + str(train_acc) + ", test acc:" + str(test_acc) + " ===")
self.current_iter += 1
def train(self):
for i in range(self.max_iter):
self.train_step()
test_acc = self.network.accuracy(self.x_test, self.t_test)
if self.verbose:
print("=============== Final Test Accuracy ===============")
print("test acc:" + str(test_acc))
在神經(jīng)網(wǎng)絡(luò)訓(xùn)練中，epoch參數(shù)是指將整個(gè)訓(xùn)練集通過(guò)模型一次，并更新模型參數(shù)的過(guò)程。每一次epoch，模型都會(huì)將訓(xùn)練集中的所有樣本通過(guò)一次，并根據(jù)這些樣本的標(biāo)簽和模型預(yù)測(cè)的結(jié)果計(jì)算損失值，然后根據(jù)損失值對(duì)模型的參數(shù)進(jìn)行更新。這個(gè)過(guò)程會(huì)重復(fù)進(jìn)行，直到達(dá)到預(yù)設(shè)的epoch數(shù)。
正式開(kāi)始預(yù)訓(xùn)練，要準(zhǔn)備好訓(xùn)練數(shù)據(jù)集，初始化CNN，梯度優(yōu)化參數(shù)，超參數(shù)存儲(chǔ)路徑等。如下所示:
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 為了導(dǎo)入父目錄的文件而進(jìn)行的設(shè)定
import numpy as np
import matplotlib.pyplot as plt
from DeepLearn_Base.dataset.mnist import load_mnist
from simple_convnet import SimpleConvNet
from DeepLearn_Base.common.trainer import Trainer
# 讀入數(shù)據(jù)
# 輸入數(shù)據(jù)的表現(xiàn)形式，可以是多維的，可以是展平(reshape)為一維的
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
# 處理花費(fèi)時(shí)間較長(zhǎng)的情況下減少數(shù)據(jù)，截取部分?jǐn)?shù)據(jù)
# 訓(xùn)練數(shù)據(jù)截取 5000 條
# 測(cè)試數(shù)據(jù)截取 1000 條
x_train, t_train = x_train[:5000], t_train[:5000]
x_test, t_test = x_test[:1000], t_test[:1000]
# 初始化epoch
max_epochs = 20
# 初始化CNN
# input_dim, 輸入數(shù)據(jù): channel, height, width
# conv_param, 卷積核參數(shù): filter_num:卷積核數(shù)量; filter_size:卷積核大小; stride:步幅; pad:填充; 30個(gè)5 × 5，通道為1的卷積核
network = SimpleConvNet(input_dim=(1,28,28),
conv_param = {'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},
hidden_size=100, output_size=10, weight_init_std=0.01)
# 初始化預(yù)訓(xùn)練
# optimizer: 梯度優(yōu)化算法; lr表示學(xué)習(xí)率
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=max_epochs, mini_batch_size=100,
optimizer='Adam', optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000)
trainer.train()
# 保存參數(shù)
network.save_params("E:\\workcode\\code\\DeepLearn_Base\\ch07\\cnn_params.pkl")
print("Saved Network Parameters!")
# 繪制圖形
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, trainer.train_acc_list, marker='o', label='train', markevery=2)
plt.plot(x, trainer.test_acc_list, marker='s', label='test', markevery=2)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()
預(yù)訓(xùn)練好后，查看是否生成超參數(shù)文件。
推理
準(zhǔn)備好測(cè)試數(shù)據(jù)集，應(yīng)用已預(yù)訓(xùn)練好的神經(jīng)網(wǎng)絡(luò)模型與超參數(shù)。
# coding: utf-8
import sys, os
# 為了導(dǎo)入父目錄的文件而進(jìn)行的設(shè)定
sys.path.append(os.pardir)
import numpy as np
from DeepLearn_Base.dataset.mnist import load_mnist
from DeepLearn_Base.common.functions import sigmoid, softmax
from simple_convnet import SimpleConvNet
def get_data():
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
return x_test, t_test
# 下載mnist數(shù)據(jù)集
# 分別下載測(cè)試圖像包、測(cè)試標(biāo)簽包、訓(xùn)練圖像包、訓(xùn)練標(biāo)簽包
x, t = get_data()
conv = SimpleConvNet()
# 獲取預(yù)訓(xùn)練好的權(quán)重與偏置參數(shù)
conv.load_params("E:\\workcode\\code\\DeepLearn_Base\\ch07\\cnn_params.pkl")
# 初始化
batch_size = 100
accuracy_cnt = 0
for i in range(int(x.shape[0] / batch_size)):
# 批次取數(shù)據(jù)
x_batch = x[i * batch_size : (i+1) * batch_size]
tt = t[i * batch_size : (i+1) * batch_size]
# 執(zhí)行推理
y_batch = conv.predict(x_batch)
p = np.argmax(y_batch, axis=1)
# 統(tǒng)計(jì)預(yù)測(cè)正確的數(shù)據(jù)
accuracy_cnt += np.sum(p == tt)
print(f'第 {i} 批次，輸入數(shù)據(jù)量{(i+1) * batch_size}個(gè)，準(zhǔn)確預(yù)測(cè)數(shù)為 {accuracy_cnt}')
print("Accuracy:" + str(float(accuracy_cnt) / x.shape[0]))
最后的輸出如下:文章來(lái)源：http://www.zghlxwxcb.cn/news/detail-748540.html
文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-748540.html
到了這里，關(guān)于聊聊神經(jīng)網(wǎng)絡(luò)模型流程與卷積神經(jīng)網(wǎng)絡(luò)的實(shí)現(xiàn)的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
