神经网络模型流程
神经网络模型的搭建流程，整理下自己的思路，这个过程不会细分出来，而是主流程。
在这里我主要是把整个流程分为两个主流程，即预训练与推理。预训练过程主要是生成超参数文件与搭设神经网络结构；而推理过程就是在应用超参数与神经网络。
卷积神经网络的实现
在 聊聊卷积神经网络CNN中，将卷积神经的理论概述了一下，现在要大概的实践了。整个代码不基于pytorch/tensorflow这类大框架，而是基于numpy库原生来实现算法。pytorch/tensorflow中的算子/函数只是由别人已实现了，我们调用而已；而基于numpy要自己实现一遍，虽然并不很严谨，但用于学习足以。
源代码是来自《深度学习入门：基于Python的理论与实现》，可以在 https://www.ituring.com.cn/book/1921 上获取下载
搭建CNN
网络构成如下:
如图所示，网络的构成是"Conv-ReLU-Pooling-Affine-ReLU-Affine-Softmax". 对于卷积层与池化层的计算，由于其是四维数据(数据量,通道,高,长)，不太好计算，使用im2col函数将其展开成二维 2 × 2的数据，最后输出时，利用numpy库的reshape函数转换输出的大小，方便计算。其示意图如下:
这样也满足了矩阵内积计算的要求，即 行列数要对应
CNN程序代码实现如下:
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
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:
"""简单的ConvNet
conv - relu - pool - affine - relu - affine - softmax
Parameters
----------
input_dim: 输入数据的维度，通道、高、长
conv_param: 卷积核参数; filter_num:卷积核数量; filter_size:卷积核大小; stride:步幅; pad:填充
input_size : 输入大小（MNIST的情况下为784）
hidden_size_list : 隐藏层的神经元数量的列表（e.g. [100, 100, 100]）
output_size : 输出大小（MNIST的情况下为10）
activation : 'relu' or 'sigmoid'
weight_init_std : 指定权重的标准差（e.g. 0.01）
指定'relu'或'he'的情况下设定“He的初始值”
指定'sigmoid'或'xavier'的情况下设定“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))
# 初始化权重
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()
# 需要处理数据，将输入数据的多维与卷积核的多维分别展平后做矩阵运算
# 在神经网络的中间层(conv,relu,pooling,affine等)的forward函数中用到了img2col与reshape结合展平数据，用向量内积运算
def predict(self, x):
for layer in self.layers.values():
x = layer.forward(x)
return x
def loss(self, x, t):
"""求损失函数
参数x是输入数据、t是教师标签
"""
y = self.predict(x)
return self.last_layer.forward(y, t)
# 计算精确度
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):
"""求梯度（数值微分）
Parameters
----------
x : 输入数据
t : 教师标签
Returns
-------
具有各层的梯度的字典变量
grads['W1']、grads['W2']、...是各层的权重
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 : 输入数据
t : 教师标签
Returns
-------
具有各层的梯度的字典变量
grads['W1']、grads['W2']、...是各层的权重
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)
# 设定
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)]
激活函数与卷积函数的实现代码没有详细的写出来，可以自己去下载查看
在这整个的过程中，我个人觉得最难的就是神经网络层的搭建与数据的计算。前者决定了神经网络的结构，而后者决定了是否最终结果。通过将数据展平，才能方便，正确的进行向量内积计算。
预训练
trainer.py文件是进行神经网络训练的类，会统计执行完一个epoch后的精确度，过程要选择梯度更新算法，学习率，批大小，epoch次数等参数。
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import numpy as np
from DeepLearn_Base.common.optimizer import *
class Trainer:
"""进行神经网络的训练的类
epochs: 以所有数据走完前向、后向传播为一次;该数值表示为总次数
mini_batch_size: 100; 每批次迭代多少数据
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: 梯度更新优化器; 更新多种梯度更新算法实现梯度更新.
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):
# 随机挑选批次的数据进行梯度更新
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]
# 开始更新梯度
grads = self.network.gradient(x_batch, t_batch)
self.optimizer.update(self.network.params, grads)
# 计算损失
loss = self.network.loss(x_batch, t_batch)
self.train_loss_list.append(loss)
if self.verbose: print("train loss:" + str(loss))
# 计算是否完成了一个epoch的执行
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))
在神经网络训练中，epoch参数是指将整个训练集通过模型一次，并更新模型参数的过程。每一次epoch，模型都会将训练集中的所有样本通过一次，并根据这些样本的标签和模型预测的结果计算损失值，然后根据损失值对模型的参数进行更新。这个过程会重复进行，直到达到预设的epoch数。
正式开始预训练，要准备好训练数据集，初始化CNN，梯度优化参数，超参数存储路径等。如下所示:
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
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
# 读入数据
# 输入数据的表现形式，可以是多维的，可以是展平(reshape)为一维的
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
# 处理花费时间较长的情况下减少数据，截取部分数据
# 训练数据截取 5000 条
# 测试数据截取 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, 输入数据: channel, height, width
# conv_param, 卷积核参数: filter_num:卷积核数量; filter_size:卷积核大小; stride:步幅; pad:填充; 30个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)
# 初始化预训练
# optimizer: 梯度优化算法; lr表示学习率
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()
# 保存参数
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()
预训练好后，查看是否生成超参数文件。
推理
准备好测试数据集，应用已预训练好的神经网络模型与超参数。
# coding: utf-8
import sys, os
# 为了导入父目录的文件而进行的设定
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数据集
# 分别下载测试图像包、测试标签包、训练图像包、训练标签包
x, t = get_data()
conv = SimpleConvNet()
# 获取预训练好的权重与偏置参数
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)):
# 批次取数据
x_batch = x[i * batch_size : (i+1) * batch_size]
tt = t[i * batch_size : (i+1) * batch_size]
# 执行推理
y_batch = conv.predict(x_batch)
p = np.argmax(y_batch, axis=1)
# 统计预测正确的数据
accuracy_cnt += np.sum(p == tt)
print(f'第 {i} 批次，输入数据量{(i+1) * batch_size}个，准确预测数为 {accuracy_cnt}')
print("Accuracy:" + str(float(accuracy_cnt) / x.shape[0]))
最后的输出如下:文章来源：https://www.toymoban.com/news/detail-750522.html
文章来源地址https://www.toymoban.com/news/detail-750522.html
到了这里，关于聊聊神经网络模型搭建流程与卷积神经网络的实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
